helloloop 0.1.2 → 0.2.0

package/hosts/claude/marketplace/plugins/helloloop/skills/helloloop/SKILL.md

@@ -0,0 +1,38 @@
+---
+name: helloloop
+description: 当用户希望 Claude Code 按开发文档先分析当前进度，再展示确认单，并在确认后持续接续开发时使用。
+---
+
+# HelloLoop for Claude Code
+
+这是 `HelloLoop` 的 Claude Code 原生技能入口。
+
+## 默认流程
+
+1. 自动识别目标仓库与开发文档
+2. 分析当前代码与文档目标之间的真实进度和偏差
+3. 在目标仓库根目录创建或刷新 `.helloloop/`
+4. 输出中文执行确认单
+5. 用户确认后，继续用 Claude Code 原生工具接续开发、测试和验收
+
+## 关键规则
+
+- 如果缺少目标仓库或开发文档，必须停下来询问用户。
+- 不允许跳过执行确认单直接开始正式开发。
+- 不允许把开发文档整体压成一个大任务；需要输出足够细的 backlog。
+- 代码是事实源，开发文档是目标源。
+- 遇到失败、阻塞、依赖未满足或风险超出自动阈值时，必须明确说明当前状态。
+
+## `.helloloop/` 最低要求
+
+- `backlog.json`
+- `project.json`
+- `status.json`
+- `STATE.md`
+- `runs/`
+
+## 安全要求
+
+- Windows 上避免使用危险的嵌套命令、拼接删除命令和 `cmd` 风格破坏性流程。
+- 不允许静默失败、静默回退、吞掉错误。
+- 真正执行前先确认，真正结束前先验证。

package/hosts/gemini/extension/GEMINI.md

@@ -0,0 +1,29 @@
+# HelloLoop for Gemini CLI
+
+你正在使用 `HelloLoop` 的 Gemini CLI 原生扩展。
+
+## 工作目标
+
+基于开发文档持续推进仓库开发，先分析真实进度，再在确认后自动接续开发、测试和验收。
+
+## 默认流程
+
+1. 自动识别项目仓库与开发文档
+2. 分析当前代码与开发文档的差距
+3. 在目标仓库根目录创建或刷新 `.helloloop/`
+4. 输出中文执行确认单
+5. 用户确认后，再继续执行后续开发任务
+
+## 强制规则
+
+- 代码是事实源，开发文档是目标源。
+- 开发前必须先输出执行确认单。
+- 如果无法识别目标仓库或开发文档，必须停下来询问用户。
+- 如果识别到偏差修正任务，优先收口偏差，再推进后续 backlog。
+- 真正执行前确认，真正结束前验证。
+
+## Windows 安全
+
+- 谨慎使用 shell；优先使用原生文件工具完成读写与目录操作。
+- 禁止危险删除、格式化、强推、硬重置等命令。
+- 不允许通过路径拼接生成破坏性命令。

package/hosts/gemini/extension/commands/helloloop.toml

@@ -0,0 +1,24 @@
+description = "根据开发文档分析当前进度、生成确认单，并在确认后继续接续开发"
+prompt = """
+你现在正在执行 HelloLoop 的 Gemini CLI 原生工作流。
+
+执行要求：
+
+1. 自动识别目标仓库与开发文档；如果用户在命令后提供了参数，只把它解释为一个路径。
+2. 分析当前代码与开发文档之间的真实进度和偏差。
+3. 在目标仓库根目录创建或刷新 `.helloloop/`，至少维护 `backlog.json`、`project.json`、`status.json`、`STATE.md` 与 `runs/`。
+4. 在真正开发前，必须输出中文执行确认单，至少包含：
+   - 目标仓库
+   - 开发文档
+   - 当前进度
+   - 已实现事项
+   - 待完成事项
+   - 任务统计
+   - 首个待执行任务
+   - 验证命令预览
+   - 自动执行停止条件
+5. 用户未确认前，不要开始正式修改代码。
+6. 用户确认后，继续用 Gemini CLI 原生工具推进 backlog，直到完成、遇到硬阻塞，或需要用户补充关键信息。
+7. 如果用户给了开发文档但找不到项目仓库，或给了项目路径但找不到开发文档，必须停下来询问。
+8. Windows 上优先用安全的文件与 shell 操作；禁止危险删除、硬重置、强推和其他破坏性命令。
+"""

package/hosts/gemini/extension/gemini-extension.json

@@ -0,0 +1,13 @@
+{
+  "name": "helloloop",
+  "version": "0.2.0",
+  "description": "HelloLoop 的 Gemini CLI 原生扩展，用于按开发文档接续推进项目开发。",
+  "contextFileName": "GEMINI.md",
+  "excludeTools": [
+    "run_shell_command(rm -rf)",
+    "run_shell_command(git reset --hard)",
+    "run_shell_command(git push --force)",
+    "run_shell_command(FLUSHALL)",
+    "run_shell_command(FLUSHDB)"
+  ]
+}

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "helloloop",
-  "version": "0.1.2",
-  "description": "面向 Codex 的独立插件 bundle，用于基于 backlog 持续推进仓库开发并执行验证循环",
-  "author": "HelloWind",
+  "version": "0.2.0",
+  "description": "面向 Codex CLI、Claude Code、Gemini CLI 的多宿主开发工作流插件",
+  "author": "HelloLoop",
   "license": "Apache-2.0",
   "homepage": "https://github.com/hellowind777/helloloop",
   "type": "module",
@@ -17,10 +17,12 @@
     "helloloop": "bin/helloloop.js"
   },
   "files": [
+    ".claude-plugin",
     ".codex-plugin",
     "LICENSE",
     "README.md",
     "bin",
+    "hosts",
     "package.json",
     "scripts",
     "skills",

package/skills/helloloop/SKILL.md

@@ -1,12 +1,29 @@
 ---
 name: helloloop
-description: 当用户希望 Codex 先分析仓库当前进度，再生成 backlog 并按队列持续接续开发时使用。
+description: 当用户希望 Codex 先分析仓库当前进度、生成确认单，再自动按 backlog 持续接续开发时使用。
 ---
 
 # HelloLoop
 
 当任务目标不是单轮对话里改一点代码，而是要基于开发文档持续推进整个仓库时，使用这个插件。
 
+## 强制入口规则
+
+- 用户显式调用 `$helloloop` / `helloloop:helloloop` 时，默认必须优先执行 `npx helloloop` 或 `npx helloloop <PATH>`。
+- 不允许在对话里手工模拟 `HelloLoop` 的分析、确认单、backlog 编排和自动续跑流程来代替 CLI。
+- 只有在以下情况，才允许先停下来问用户而不是直接执行 CLI：
+  1. 用户既没有给路径，当前目录也无法判断项目仓库或开发文档
+  2. 用户给了开发文档，但无法定位目标项目仓库
+  3. 用户给了项目路径，但无法找到开发文档
+  4. 用户明确要求先只讲解、不执行
+
+## `$helloloop` 的默认执行映射
+
+- 当前目录已经是目标项目仓库或开发文档目录 → 先执行 `npx helloloop`
+- 用户给了单一路径 → 先执行 `npx helloloop <PATH>`
+- 用户明确只想先看分析和确认单 → 执行 `npx helloloop --dry-run`
+- 用户明确要求跳过确认直接开始 → 执行 `npx helloloop -y`
+
 ## 插件边界
 
 - 当前 bundle 根目录就是 `HelloLoop` 的官方插件目录。
@@ -17,30 +34,37 @@ description: 当用户希望 Codex 先分析仓库当前进度，再生成 backl
 
 1. 先通过 `npx helloloop install --codex-home <CODEX_HOME>` 或 `scripts/install-home-plugin.ps1` 安装插件。
 2. 打开目标项目仓库目录，或者打开开发文档所在目录。
-3. 运行 `npx helloloop` 或 `npx helloloop <path>`。
-4. 如果无法自动判断仓库路径或开发文档路径，就停下来提示用户补充；`--repo` 和 `--docs` 只作为显式覆盖选项使用。
+3. 运行 `npx helloloop` 或 `npx helloloop <PATH>`。
+4. 命中 `$helloloop` 后，优先按上面的默认执行映射直接调用 CLI。
+5. `HelloLoop` 会先自动分析，再输出执行确认单。
+6. 用户确认后，`HelloLoop` 才开始正式自动执行。
+
+如果无法自动判断仓库路径或开发文档路径，就停下来提示用户补充；`--repo` 和 `--docs` 只作为显式覆盖选项使用。
 
 ## 工作模式
 
 - 代码是事实源，开发文档是目标源。
 - `HelloLoop` 会先分析当前真实进度，再生成或刷新 `.helloloop/backlog.json`。
-- 后续开发通过 `next`、`run-once`、`run-loop` 按 backlog 接续推进。
+- 分析后会展示执行确认单，明确告知当前进度、待办任务、验证命令和执行边界。
+- 用户确认后，默认会持续执行到 backlog 清空或遇到硬阻塞。
 - 真正的代码分析与实现仍由本机 `codex` CLI 完成。
+- `$helloloop` 的职责是把用户请求路由到主 CLI 流程，而不是在对话里手工复刻一套平行流程。
 
 ## 核心命令
 
 - `npx helloloop`
-- `npx helloloop <path>`
-- `npx helloloop next`
-- `npx helloloop run-once`
-- `npx helloloop run-loop --max-tasks <n>`
+- `npx helloloop <PATH>`
+- `npx helloloop --dry-run`
+- `npx helloloop -y`
 
-## 高级命令
+## 手动控制命令
 
 - `npx helloloop status`
+- `npx helloloop next`
+- `npx helloloop run-once`
+- `npx helloloop run-loop --max-tasks <n>`
 - `npx helloloop doctor`
 - `npx helloloop init`
-- `npx helloloop --repo <repo-root> --docs <docs-path>`
 
 ## 调用方式
 

package/src/analyze_confirmation.mjs

@@ -0,0 +1,128 @@
+import path from "node:path";
+
+import { analyzeExecution, summarizeBacklog } from "./backlog.mjs";
+import { loadPolicy, loadVerifyCommands } from "./config.mjs";
+
+function toDisplayPath(repoRoot, targetPath) {
+  const absolutePath = path.resolve(targetPath);
+  const relativePath = path.relative(repoRoot, absolutePath);
+  if (relativePath && !relativePath.startsWith("..") && !path.isAbsolute(relativePath)) {
+    return relativePath.replaceAll("\\", "/");
+  }
+  return absolutePath.replaceAll("\\", "/");
+}
+
+function formatList(items, fallback = "无") {
+  if (!Array.isArray(items) || !items.length) {
+    return [`- ${fallback}`];
+  }
+  return items.map((item) => `- ${item}`);
+}
+
+function formatTaskPreview(tasks) {
+  const preview = tasks
+    .filter((task) => ["pending", "in_progress"].includes(String(task.status || "pending")))
+    .slice(0, 5);
+
+  if (!preview.length) {
+    return ["- 当前没有待执行任务"];
+  }
+
+  return preview.map((task) => {
+    const parts = [
+      task.title,
+      `#${task.id}`,
+      task.priority || "P2",
+      `risk:${task.risk || "low"}`,
+    ];
+    return `- ${parts.join(" | ")}`;
+  });
+}
+
+function formatExecutionState(execution) {
+  const stateMap = {
+    ready: "可自动执行",
+    blocked_in_progress: "存在未收束任务",
+    blocked_failed: "存在失败或阻塞任务",
+    blocked_risk: "风险超过自动阈值",
+    blocked_dependencies: "依赖未满足",
+    done: "backlog 已完成",
+  };
+
+  return stateMap[execution.state] || execution.state;
+}
+
+function resolvePreviewVerifyCommands(context, execution) {
+  const taskCommands = Array.isArray(execution.task?.verify) && execution.task.verify.length
+    ? execution.task.verify
+    : [];
+  if (taskCommands.length) {
+    return taskCommands;
+  }
+  return loadVerifyCommands(context);
+}
+
+export function resolveAutoRunMaxTasks(backlog, options = {}) {
+  const explicitMaxTasks = Number(options.maxTasks);
+  if (Number.isFinite(explicitMaxTasks) && explicitMaxTasks > 0) {
+    return explicitMaxTasks;
+  }
+
+  const summary = summarizeBacklog(backlog);
+  const pendingTotal = summary.pending + summary.inProgress;
+  return Math.max(1, pendingTotal);
+}
+
+export function renderAnalyzeConfirmation(context, analysis, backlog, options = {}) {
+  const summary = summarizeBacklog(backlog);
+  const execution = analyzeExecution(backlog, options);
+  const policy = loadPolicy(context);
+  const verifyCommands = resolvePreviewVerifyCommands(context, execution);
+  const autoRunMaxTasks = resolveAutoRunMaxTasks(backlog, options);
+  const docsDisplay = analysis.requiredDocs.map((entry) => (
+    toDisplayPath(context.repoRoot, path.resolve(context.repoRoot, entry))
+  ));
+
+  return [
+    "执行确认单",
+    "============",
+    `目标仓库：${context.repoRoot.replaceAll("\\", "/")}`,
+    `开发文档：${docsDisplay.length ? docsDisplay.join("，") : "未识别"}`,
+    "",
+    "当前进度：",
+    `- ${analysis.summary.currentState}`,
+    "",
+    "已实现：",
+    ...formatList(analysis.summary.implemented, "暂无已实现摘要"),
+    "",
+    "待完成：",
+    ...formatList(analysis.summary.remaining, "暂无待完成摘要"),
+    "",
+    "任务统计：",
+    `- 总任务：${summary.total}`,
+    `- 已完成：${summary.done}`,
+    `- 待处理：${summary.pending}`,
+    `- 进行中：${summary.inProgress}`,
+    `- 阻塞：${summary.blocked}`,
+    `- 失败：${summary.failed}`,
+    "",
+    "执行判断：",
+    `- 当前状态：${formatExecutionState(execution)}`,
+    `- 优先动作：${analysis.summary.nextAction}`,
+    execution.task
+      ? `- 首个任务：${execution.task.title}`
+      : `- 首个任务：${execution.blockedTask?.title || "暂无"}`,
+    execution.blockedReason
+      ? `- 当前阻塞：${execution.blockedReason}`
+      : "- 当前阻塞：无",
+    "- 偏差修正：按 backlog 优先级执行；如果分析识别出偏差修正任务，会先收口再继续后续开发",
+    `- 自动推进：最多 ${autoRunMaxTasks} 个任务，直到 backlog 清空或遇到硬阻塞`,
+    `- 单任务重试：每种策略最多 ${policy.maxTaskAttempts} 次，共 ${policy.maxTaskStrategies} 轮策略`,
+    "",
+    "待执行任务预览：",
+    ...formatTaskPreview(backlog.tasks),
+    "",
+    "验证命令预览：",
+    ...formatList(verifyCommands, "未配置 verify.yaml，执行阶段将仅依赖任务自带验证"),
+  ].join("\n");
+}

package/src/analyzer.mjs

@@ -87,8 +87,8 @@ function buildAnalysisSummaryText(context, analysis, backlog) {
     nextTask ? `下一任务：${nextTask.title}` : "下一任务：暂无可执行任务",
     "",
     "下一步建议：",
-    `- npx helloloop next`,
-    `- npx helloloop run-once`,
+    `- npx helloloop`,
+    `- npx helloloop --dry-run`,
   ].join("\n");
 }
 

package/src/cli.mjs

@@ -1,10 +1,16 @@
 import path from "node:path";
-import { spawnSync } from "node:child_process";
 
+import { analyzeExecution } from "./backlog.mjs";
+import { renderAnalyzeConfirmation, resolveAutoRunMaxTasks } from "./analyze_confirmation.mjs";
+import {
+  confirmAutoExecution,
+  renderAnalyzeStopMessage,
+  renderAutoRunSummary,
+  runDoctor,
+} from "./cli_support.mjs";
 import { createContext } from "./context.mjs";
-import { fileExists } from "./common.mjs";
 import { analyzeWorkspace } from "./analyzer.mjs";
-import { scaffoldIfMissing } from "./config.mjs";
+import { loadBacklog, scaffoldIfMissing } from "./config.mjs";
 import { resolveRepoRoot } from "./discovery.mjs";
 import { installPluginBundle } from "./install.mjs";
 import { runLoop, runOnce, renderStatusText } from "./runner.mjs";
@@ -41,6 +47,7 @@ function parseArgs(argv) {
   for (let index = 0; index < rest.length; index += 1) {
     const arg = rest[index];
     if (arg === "--dry-run") options.dryRun = true;
+    else if (arg === "--yes" || arg === "-y") options.yes = true;
     else if (arg === "--allow-high-risk") options.allowHighRisk = true;
     else if (arg === "--force") options.force = true;
     else if (arg === "--task-id") { options.taskId = rest[index + 1]; index += 1; }
@@ -49,7 +56,10 @@ function parseArgs(argv) {
     else if (arg === "--max-strategies") { options.maxStrategies = Number(rest[index + 1]); index += 1; }
     else if (arg === "--repo") { options.repoRoot = rest[index + 1]; index += 1; }
     else if (arg === "--docs") { options.docsPath = rest[index + 1]; index += 1; }
+    else if (arg === "--host") { options.host = rest[index + 1]; index += 1; }
     else if (arg === "--codex-home") { options.codexHome = rest[index + 1]; index += 1; }
+    else if (arg === "--claude-home") { options.claudeHome = rest[index + 1]; index += 1; }
+    else if (arg === "--gemini-home") { options.geminiHome = rest[index + 1]; index += 1; }
     else if (arg === "--config-dir") { options.configDirName = rest[index + 1]; index += 1; }
     else if (arg === "--required-doc") { options.requiredDocs.push(rest[index + 1]); index += 1; }
     else if (arg === "--constraint") { options.constraints.push(rest[index + 1]); index += 1; }
@@ -67,7 +77,7 @@ function helpText() {
     "用法：helloloop [command] [path] [options]",
     "",
     "命令：",
-    "  analyze               自动发现仓库与开发文档，分析当前进度并生成/刷新 .helloloop（默认）",
+    "  analyze               自动分析并生成执行确认单；确认后继续自动接续开发（默认）",
     "  install               安装插件到 Codex Home（适合 npx / npm bin 分发）",
     "  init                  初始化 .helloloop 配置",
     "  status                查看 backlog 与下一任务",
@@ -77,11 +87,15 @@ function helpText() {
     "  doctor                检查 Codex、当前插件 bundle 与目标仓库 .helloloop 配置是否可用",
     "",
     "选项：",
+    "  --host <name>        安装宿主：codex | claude | gemini | all（默认 codex）",
     "  --codex-home <dir>    Codex Home，install 默认使用 ~/.codex",
+    "  --claude-home <dir>   Claude Home，install 默认使用 ~/.claude",
+    "  --gemini-home <dir>   Gemini Home，install 默认使用 ~/.gemini",
     "  --repo <dir>          高级选项：显式指定项目仓库根目录",
     "  --docs <dir|file>     高级选项：显式指定开发文档目录或文件",
     "  --config-dir <dir>    配置目录，默认 .helloloop",
-    "  --dry-run             只生成提示与预览，不真正调用 codex",
+    "  -y, --yes             跳过交互确认，分析后直接开始自动执行",
+    "  --dry-run             只分析并输出确认单，不真正开始自动执行",
     "  --task-id <id>        指定任务 id",
     "  --max-tasks <n>       run-loop 最多执行 n 个任务",
     "  --max-attempts <n>    每种策略内最多重试 n 次",
@@ -100,90 +114,37 @@ function renderFollowupExamples() {
   return [
     "下一步示例：",
     `npx helloloop`,
+    `npx helloloop <PATH>`,
+    `npx helloloop --dry-run`,
+    `npx helloloop install --host all`,
     `npx helloloop next`,
     `如需显式补充路径：npx helloloop --repo ${REPO_ROOT_PLACEHOLDER} --docs ${DOCS_PATH_PLACEHOLDER}`,
   ].join("\n");
 }
 
-function probeCodexVersion() {
-  const codexVersion = process.platform === "win32"
-    ? spawnSync("codex --version", {
-        encoding: "utf8",
-        shell: true,
-      })
-    : spawnSync("codex", ["--version"], {
-        encoding: "utf8",
-        shell: false,
-      });
-  const ok = codexVersion.status === 0;
-  return {
-    ok,
-    detail: ok
-      ? String(codexVersion.stdout || "").trim()
-      : String(codexVersion.stderr || codexVersion.error || "无法执行 codex --version").trim(),
-  };
-}
-
-function collectDoctorChecks(context) {
-  const codexVersion = probeCodexVersion();
-  return [
-    {
-      name: "codex CLI",
-      ok: codexVersion.ok,
-      detail: codexVersion.detail,
-    },
-    {
-      name: "backlog.json",
-      ok: fileExists(context.backlogFile),
-      detail: context.backlogFile,
-    },
-    {
-      name: "policy.json",
-      ok: fileExists(context.policyFile),
-      detail: context.policyFile,
-    },
-    {
-      name: "verify.yaml",
-      ok: fileExists(context.repoVerifyFile),
-      detail: context.repoVerifyFile,
-    },
-    {
-      name: "project.json",
-      ok: fileExists(context.projectFile),
-      detail: context.projectFile,
-    },
-    {
-      name: "plugin manifest",
-      ok: fileExists(context.pluginManifestFile),
-      detail: context.pluginManifestFile,
-    },
-    {
-      name: "plugin skill",
-      ok: fileExists(context.skillFile),
-      detail: context.skillFile,
-    },
-    {
-      name: "install script",
-      ok: fileExists(context.installScriptFile),
-      detail: context.installScriptFile,
-    },
+function renderInstallSummary(result) {
+  const lines = [
+    "HelloLoop 已安装到以下宿主：",
   ];
-}
-
-async function runDoctor(context) {
-  const checks = collectDoctorChecks(context);
-
-  for (const item of checks) {
-    console.log(`${item.ok ? "OK" : "FAIL"}  ${item.name}  ${item.detail}`);
-  }
 
-  if (checks.every((item) => item.ok)) {
-    console.log("\nDoctor 结论：当前 HelloLoop bundle 与目标仓库已具备基本运行条件。");
+  for (const item of result.installedHosts) {
+    lines.push(`- ${item.displayName}：${item.targetRoot}`);
+    if (item.marketplaceFile) {
+      lines.push(`  marketplace：${item.marketplaceFile}`);
+    }
+    if (item.settingsFile) {
+      lines.push(`  settings：${item.settingsFile}`);
+    }
   }
 
-  if (checks.some((item) => !item.ok)) {
-    process.exitCode = 1;
-  }
+  lines.push("");
+  lines.push("使用入口：");
+  lines.push("- Codex：`$helloloop` / `npx helloloop`");
+  lines.push("- Claude：`/helloloop`");
+  lines.push("- Gemini：`/helloloop`");
+  lines.push("");
+  lines.push(renderFollowupExamples());
+  return lines.join("\n");
 }
 
 function resolveContextFromOptions(options) {
@@ -218,13 +179,13 @@ export async function runCli(argv) {
     });
     const result = installPluginBundle({
       bundleRoot: context.bundleRoot,
+      host: options.host,
       codexHome: options.codexHome,
+      claudeHome: options.claudeHome,
+      geminiHome: options.geminiHome,
       force: options.force,
     });
-    console.log(`HelloLoop 已安装到：${result.targetPluginRoot}`);
-    console.log(`Marketplace 已更新：${result.marketplaceFile}`);
-    console.log("");
-    console.log(renderFollowupExamples());
+    console.log(renderInstallSummary(result));
     return;
   }
 
@@ -243,7 +204,39 @@ export async function runCli(argv) {
       return;
     }
 
-    console.log(result.summary);
+    const confirmationText = renderAnalyzeConfirmation(result.context, result.analysis, result.backlog, options);
+    const execution = analyzeExecution(result.backlog, options);
+
+    console.log(confirmationText);
+    console.log("");
+
+    if (options.dryRun) {
+      console.log("已按 --dry-run 跳过自动执行。");
+      return;
+    }
+
+    if (execution.state !== "ready") {
+      console.log(renderAnalyzeStopMessage(execution.blockedReason || "当前 backlog 已无可自动执行任务。"));
+      return;
+    }
+
+    const approved = options.yes ? true : await confirmAutoExecution();
+    if (!approved) {
+      console.log("已取消自动执行；分析结果与 backlog 已保留在 .helloloop/。");
+      return;
+    }
+
+    console.log("");
+    console.log("开始自动接续执行...");
+    const results = await runLoop(result.context, {
+      ...options,
+      maxTasks: resolveAutoRunMaxTasks(result.backlog, options),
+    });
+    const refreshedBacklog = loadBacklog(result.context);
+    console.log(renderAutoRunSummary(result.context, refreshedBacklog, results, options));
+    if (results.some((item) => !item.ok)) {
+      process.exitCode = 1;
+    }
     return;
   }
 
@@ -263,7 +256,7 @@ export async function runCli(argv) {
   }
 
   if (command === "doctor") {
-    await runDoctor(context);
+    await runDoctor(context, options);
     return;
   }