geo-ai-search-optimization 1.3.6 → 1.3.7

package/README.md

@@ -879,6 +879,13 @@ geo-ai-search-optimization help
 - 主 `cli.js` 现在只保留 `version / help / command routing`
 - CLI 已经形成 `shell / flow / execution / planning-delivery / site-ops / shared` 六层 command adapter 结构
 
+## New in 1.3.7
+
+- 开始把重复的 artifact 编排从 adapter 中抽成共享组合器
+- `src/cli-shared.js` 新增 `createArtifactCommandHandler` 和 `createPackCommandHandler`
+- `src/cli-agent-execution-commands.js` 与 `src/cli-planning-delivery-commands.js` 现在改用声明式组合，减少重复的 `create / render / write` handler 模板代码
+- CLI 架构从“按命令族拆文件”进一步推进到“adapter + shared composition”模式
+
 ## New in 1.2.20
 
 - 新增 `agent-continue`

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "geo-ai-search-optimization",
-  "version": "1.3.6",
+  "version": "1.3.7",
   "description": "Install and run a Generative Engine Optimization (GEO)-first, SEO-supported Codex skill for website optimization.",
   "type": "module",
   "bin": {

package/src/cli-agent-execution-commands.js

@@ -20,10 +20,9 @@ import { createAgentRetrospective, renderAgentRetrospectiveMarkdown, writeAgentR
 import { createAgentStatusBoard, renderAgentStatusBoardMarkdown, writeAgentStatusBoardOutput } from "./agent-status-board.js";
 import { createAgentRunbook, renderAgentRunbookMarkdown, writeAgentRunbookOutput } from "./agent-runbook.js";
 import {
+  createArtifactCommandHandler,
   getFlagValue,
-  getJsonCapableFormat,
-  getRequiredInput,
-  writeOrPrintArtifact
+  getJsonCapableFormat
 } from "./cli-shared.js";
 
 export const AGENT_EXECUTION_HELP_LINES = [
@@ -38,164 +37,126 @@ export const AGENT_EXECUTION_HELP_LINES = [
   "  geo-ai-search-optimization agent-playbook-pack <input> [--task <id>] [--format <markdown|json>] [--out <file>]"
 ];
 
-async function handleAgentRunbook(args) {
-  const input = getRequiredInput(args, "agent-runbook");
-  const format = getFlagValue(args, "--format");
-  const artifact = await createAgentRunbook(input, {
+const handleAgentRunbook = createArtifactCommandHandler({
+  commandName: "agent-runbook",
+  commandLabel: "agent runbook",
+  createArtifact: createAgentRunbook,
+  renderMarkdown: renderAgentRunbookMarkdown,
+  writeOutput: writeAgentRunbookOutput,
+  getOptions: (args) => ({
     intent: getFlagValue(args, "--intent"),
-    format,
+    format: getFlagValue(args, "--format"),
     taskId: getFlagValue(args, "--task")
-  });
-  return writeOrPrintArtifact({
-    args,
-    commandName: "agent runbook",
-    artifact,
-    renderMarkdown: renderAgentRunbookMarkdown,
-    writeOutput: writeAgentRunbookOutput,
-    outputJson: format === "json"
-  });
-}
+  })
+});
 
-async function handleAgentExecutor(args) {
-  const input = getRequiredInput(args, "agent-executor");
-  const format = getFlagValue(args, "--format");
-  const artifact = await createAgentExecutor(input, {
+const handleAgentExecutor = createArtifactCommandHandler({
+  commandName: "agent-executor",
+  commandLabel: "agent executor",
+  createArtifact: createAgentExecutor,
+  renderMarkdown: renderAgentExecutorMarkdown,
+  writeOutput: writeAgentExecutorOutput,
+  getOptions: (args) => ({
     intent: getFlagValue(args, "--intent"),
-    format,
+    format: getFlagValue(args, "--format"),
     taskId: getFlagValue(args, "--task")
-  });
-  return writeOrPrintArtifact({
-    args,
-    commandName: "agent executor",
-    artifact,
-    renderMarkdown: renderAgentExecutorMarkdown,
-    writeOutput: writeAgentExecutorOutput,
-    outputJson: format === "json"
-  });
-}
+  })
+});
 
-async function handleAgentBatchExecutor(args) {
-  const input = getRequiredInput(args, "agent-batch-executor");
-  const artifact = await createAgentBatchExecutor(input, {
+const handleAgentBatchExecutor = createArtifactCommandHandler({
+  commandName: "agent-batch-executor",
+  commandLabel: "agent batch executor",
+  createArtifact: createAgentBatchExecutor,
+  renderMarkdown: renderAgentBatchExecutorMarkdown,
+  writeOutput: writeAgentBatchExecutorOutput,
+  getOptions: (args) => ({
     intent: getFlagValue(args, "--intent"),
     format: getJsonCapableFormat(args),
     taskId: getFlagValue(args, "--task"),
     count: getFlagValue(args, "--count")
-  });
-  return writeOrPrintArtifact({
-    args,
-    commandName: "agent batch executor",
-    artifact,
-    renderMarkdown: renderAgentBatchExecutorMarkdown,
-    writeOutput: writeAgentBatchExecutorOutput,
-    outputJson: artifact.format === "json"
-  });
-}
+  })
+});
 
-async function handleAgentProgressTracker(args) {
-  const input = getRequiredInput(args, "agent-progress-tracker");
-  const artifact = await createAgentProgressTracker(input, {
+const handleAgentProgressTracker = createArtifactCommandHandler({
+  commandName: "agent-progress-tracker",
+  commandLabel: "agent progress tracker",
+  createArtifact: createAgentProgressTracker,
+  renderMarkdown: renderAgentProgressTrackerMarkdown,
+  writeOutput: writeAgentProgressTrackerOutput,
+  getOptions: (args) => ({
     format: getJsonCapableFormat(args),
     currentTaskId: getFlagValue(args, "--current"),
     completedPacketIds: getFlagValue(args, "--completed"),
     blockedReasons: getFlagValue(args, "--blocked")
-  });
-  return writeOrPrintArtifact({
-    args,
-    commandName: "agent progress tracker",
-    artifact,
-    renderMarkdown: renderAgentProgressTrackerMarkdown,
-    writeOutput: writeAgentProgressTrackerOutput,
-    outputJson: artifact.format === "json"
-  });
-}
+  })
+});
 
-async function handleAgentStatusBoard(args) {
-  const input = getRequiredInput(args, "agent-status-board");
-  const artifact = await createAgentStatusBoard(input, {
+const handleAgentStatusBoard = createArtifactCommandHandler({
+  commandName: "agent-status-board",
+  commandLabel: "agent status board",
+  createArtifact: createAgentStatusBoard,
+  renderMarkdown: renderAgentStatusBoardMarkdown,
+  writeOutput: writeAgentStatusBoardOutput,
+  getOptions: (args) => ({
     format: getJsonCapableFormat(args),
     currentTaskId: getFlagValue(args, "--current"),
     completedPacketIds: getFlagValue(args, "--completed"),
     blockedReasons: getFlagValue(args, "--blocked")
-  });
-  return writeOrPrintArtifact({
-    args,
-    commandName: "agent status board",
-    artifact,
-    renderMarkdown: renderAgentStatusBoardMarkdown,
-    writeOutput: writeAgentStatusBoardOutput,
-    outputJson: artifact.format === "json"
-  });
-}
+  })
+});
 
-async function handleAgentCheckpoint(args) {
-  const input = getRequiredInput(args, "agent-checkpoint");
-  const artifact = await createAgentCheckpoint(input, {
+const handleAgentCheckpoint = createArtifactCommandHandler({
+  commandName: "agent-checkpoint",
+  commandLabel: "agent checkpoint",
+  createArtifact: createAgentCheckpoint,
+  renderMarkdown: renderAgentCheckpointMarkdown,
+  writeOutput: writeAgentCheckpointOutput,
+  getOptions: (args) => ({
     format: getJsonCapableFormat(args),
     currentTaskId: getFlagValue(args, "--current"),
     completedPacketIds: getFlagValue(args, "--completed"),
     blockedReasons: getFlagValue(args, "--blocked")
-  });
-  return writeOrPrintArtifact({
-    args,
-    commandName: "agent checkpoint",
-    artifact,
-    renderMarkdown: renderAgentCheckpointMarkdown,
-    writeOutput: writeAgentCheckpointOutput,
-    outputJson: artifact.format === "json"
-  });
-}
+  })
+});
 
-async function handleAgentDecisionLog(args) {
-  const input = getRequiredInput(args, "agent-decision-log");
-  const artifact = await createAgentDecisionLog(input, {
+const handleAgentDecisionLog = createArtifactCommandHandler({
+  commandName: "agent-decision-log",
+  commandLabel: "agent decision log",
+  createArtifact: createAgentDecisionLog,
+  renderMarkdown: renderAgentDecisionLogMarkdown,
+  writeOutput: writeAgentDecisionLogOutput,
+  getOptions: (args) => ({
     format: getJsonCapableFormat(args),
     appendFrom: getFlagValue(args, "--append-from"),
     note: getFlagValue(args, "--note"),
     currentTaskId: getFlagValue(args, "--current"),
     completedPacketIds: getFlagValue(args, "--completed"),
     blockedReasons: getFlagValue(args, "--blocked")
-  });
-  return writeOrPrintArtifact({
-    args,
-    commandName: "agent decision log",
-    artifact,
-    renderMarkdown: renderAgentDecisionLogMarkdown,
-    writeOutput: writeAgentDecisionLogOutput,
-    outputJson: artifact.format === "json"
-  });
-}
+  })
+});
 
-async function handleAgentRetrospective(args) {
-  const input = getRequiredInput(args, "agent-retrospective");
-  const artifact = await createAgentRetrospective(input, {
+const handleAgentRetrospective = createArtifactCommandHandler({
+  commandName: "agent-retrospective",
+  commandLabel: "agent retrospective",
+  createArtifact: createAgentRetrospective,
+  renderMarkdown: renderAgentRetrospectiveMarkdown,
+  writeOutput: writeAgentRetrospectiveOutput,
+  getOptions: (args) => ({
     format: getJsonCapableFormat(args)
-  });
-  return writeOrPrintArtifact({
-    args,
-    commandName: "agent retrospective",
-    artifact,
-    renderMarkdown: renderAgentRetrospectiveMarkdown,
-    writeOutput: writeAgentRetrospectiveOutput,
-    outputJson: artifact.format === "json"
-  });
-}
+  })
+});
 
-async function handleAgentPlaybookPack(args) {
-  const input = getRequiredInput(args, "agent-playbook-pack");
-  const artifact = await createAgentPlaybookPack(input, {
+const handleAgentPlaybookPack = createArtifactCommandHandler({
+  commandName: "agent-playbook-pack",
+  commandLabel: "agent playbook pack",
+  createArtifact: createAgentPlaybookPack,
+  renderMarkdown: renderAgentPlaybookPackMarkdown,
+  writeOutput: writeAgentPlaybookPackOutput,
+  getOptions: (args) => ({
     format: getJsonCapableFormat(args),
     taskId: getFlagValue(args, "--task")
-  });
-  return writeOrPrintArtifact({
-    args,
-    commandName: "agent playbook pack",
-    artifact,
-    renderMarkdown: renderAgentPlaybookPackMarkdown,
-    writeOutput: writeAgentPlaybookPackOutput,
-    outputJson: artifact.format === "json"
-  });
-}
+  })
+});
 
 export const AGENT_EXECUTION_COMMAND_HANDLERS = {
   "agent-runbook": handleAgentRunbook,

package/src/cli-planning-delivery-commands.js

@@ -17,7 +17,13 @@ import { renderPublishPackMarkdown, writePublishPack } from "./publish-pack.js";
 import { generateReport, writeReportOutput } from "./report.js";
 import { createRoadmap, renderRoadmapMarkdown, writeRoadmapOutput } from "./roadmap.js";
 import { createSharePack, renderSharePackMarkdown, writeSharePackOutput } from "./share-pack.js";
-import { getFlagValue, getRequiredInput, parsePositiveInteger, writeOrPrintArtifact } from "./cli-shared.js";
+import {
+  createArtifactCommandHandler,
+  createPackCommandHandler,
+  getFlagValue,
+  getRequiredInput,
+  parsePositiveInteger
+} from "./cli-shared.js";
 
 export const PLANNING_DELIVERY_HELP_LINES = [
   "  geo-ai-search-optimization agent-handoff <input> [--format <markdown|json>] [--out <file>]",
@@ -37,196 +43,160 @@ export const PLANNING_DELIVERY_HELP_LINES = [
   "  geo-ai-search-optimization report <input> [--mode <auto|audit|onboarding|scan>] [--format <markdown|html|json>] [--out <file>]"
 ];
 
-async function handleAgentHandoff(args) {
-  const input = getRequiredInput(args, "agent-handoff");
-  const format = getFlagValue(args, "--format");
-  const artifact = await createAgentHandoff(input, { format });
-  return writeOrPrintArtifact({
-    args,
-    commandName: "agent handoff",
-    artifact,
-    renderMarkdown: renderAgentHandoffMarkdown,
-    writeOutput: writeAgentHandoffOutput,
-    outputJson: format === "json"
-  });
-}
-
-async function handleApplyPlan(args) {
-  const input = getRequiredInput(args, "apply-plan");
-  const format = getFlagValue(args, "--format");
-  const artifact = await createApplyPlan(input, {
-    format,
+const handleAgentHandoff = createArtifactCommandHandler({
+  commandName: "agent-handoff",
+  commandLabel: "agent handoff",
+  createArtifact: createAgentHandoff,
+  renderMarkdown: renderAgentHandoffMarkdown,
+  writeOutput: writeAgentHandoffOutput,
+  getOptions: (args) => ({
+    format: getFlagValue(args, "--format")
+  })
+});
+
+const handleApplyPlan = createArtifactCommandHandler({
+  commandName: "apply-plan",
+  commandLabel: "apply plan",
+  createArtifact: createApplyPlan,
+  renderMarkdown: renderApplyPlanMarkdown,
+  writeOutput: writeApplyPlanOutput,
+  getOptions: (args) => ({
+    format: getFlagValue(args, "--format"),
     taskId: getFlagValue(args, "--task")
-  });
-  return writeOrPrintArtifact({
-    args,
-    commandName: "apply plan",
-    artifact,
-    renderMarkdown: renderApplyPlanMarkdown,
-    writeOutput: writeApplyPlanOutput,
-    outputJson: format === "json"
-  });
-}
-
-async function handleCompletionReport(args) {
-  const input = getRequiredInput(args, "completion-report");
-  const format = getFlagValue(args, "--format");
-  const artifact = await createCompletionReport(input, { format });
-  return writeOrPrintArtifact({
-    args,
-    commandName: "completion report",
-    artifact,
-    renderMarkdown: renderCompletionReportMarkdown,
-    writeOutput: writeCompletionReportOutput,
-    outputJson: format === "json"
-  });
-}
-
-async function handleHandoffBundle(args) {
-  const input = getRequiredInput(args, "handoff-bundle");
-  const format = getFlagValue(args, "--format");
-  const artifact = await createHandoffBundle(input, {
-    format,
+  })
+});
+
+const handleCompletionReport = createArtifactCommandHandler({
+  commandName: "completion-report",
+  commandLabel: "completion report",
+  createArtifact: createCompletionReport,
+  renderMarkdown: renderCompletionReportMarkdown,
+  writeOutput: writeCompletionReportOutput,
+  getOptions: (args) => ({
+    format: getFlagValue(args, "--format")
+  })
+});
+
+const handleHandoffBundle = createArtifactCommandHandler({
+  commandName: "handoff-bundle",
+  commandLabel: "handoff bundle",
+  createArtifact: createHandoffBundle,
+  renderMarkdown: renderHandoffBundleMarkdown,
+  writeOutput: writeHandoffBundleOutput,
+  getOptions: (args) => ({
+    format: getFlagValue(args, "--format"),
     taskId: getFlagValue(args, "--task")
-  });
-  return writeOrPrintArtifact({
-    args,
-    commandName: "handoff bundle",
-    artifact,
-    renderMarkdown: renderHandoffBundleMarkdown,
-    writeOutput: writeHandoffBundleOutput,
-    outputJson: format === "json"
-  });
-}
-
-async function handleSharePack(args) {
-  const input = getRequiredInput(args, "share-pack");
-  const format = getFlagValue(args, "--format");
-  const artifact = await createSharePack(input, {
-    format,
+  })
+});
+
+const handleSharePack = createArtifactCommandHandler({
+  commandName: "share-pack",
+  commandLabel: "share pack",
+  createArtifact: createSharePack,
+  renderMarkdown: renderSharePackMarkdown,
+  writeOutput: writeSharePackOutput,
+  getOptions: (args) => ({
+    format: getFlagValue(args, "--format"),
     taskId: getFlagValue(args, "--task")
-  });
-  return writeOrPrintArtifact({
-    args,
-    commandName: "share pack",
-    artifact,
-    renderMarkdown: renderSharePackMarkdown,
-    writeOutput: writeSharePackOutput,
-    outputJson: format === "json"
-  });
-}
-
-async function handleExportPack(args) {
-  const input = getRequiredInput(args, "export-pack");
-  const pack = await writeExportPack(input, {
+  })
+});
+
+const handleExportPack = createPackCommandHandler({
+  commandName: "export-pack",
+  writePack: writeExportPack,
+  renderMarkdown: renderExportPackMarkdown,
+  getOptions: (args) => ({
     format: getFlagValue(args, "--format"),
     taskId: getFlagValue(args, "--task"),
     outputDir: getFlagValue(args, "--out-dir")
-  });
-  process.stdout.write(renderExportPackMarkdown(pack));
-}
-
-async function handleHtmlPack(args) {
-  const input = getRequiredInput(args, "html-pack");
-  const pack = await writeHtmlPack(input, {
+  })
+});
+
+const handleHtmlPack = createPackCommandHandler({
+  commandName: "html-pack",
+  writePack: writeHtmlPack,
+  renderMarkdown: renderHtmlPackMarkdown,
+  getOptions: (args) => ({
     taskId: getFlagValue(args, "--task"),
     outputDir: getFlagValue(args, "--out-dir")
-  });
-  process.stdout.write(renderHtmlPackMarkdown(pack));
-}
-
-async function handlePublishPack(args) {
-  const input = getRequiredInput(args, "publish-pack");
-  const pack = await writePublishPack(input, {
+  })
+});
+
+const handlePublishPack = createPackCommandHandler({
+  commandName: "publish-pack",
+  writePack: writePublishPack,
+  renderMarkdown: renderPublishPackMarkdown,
+  getOptions: (args) => ({
     taskId: getFlagValue(args, "--task"),
     outputDir: getFlagValue(args, "--out-dir")
-  });
-  process.stdout.write(renderPublishPackMarkdown(pack));
-}
-
-async function handleExecSummary(args) {
-  const input = getRequiredInput(args, "exec-summary");
-  const format = getFlagValue(args, "--format");
-  const artifact = await createExecSummary(input, { format });
-  return writeOrPrintArtifact({
-    args,
-    commandName: "exec summary",
-    artifact,
-    renderMarkdown: renderExecSummaryMarkdown,
-    writeOutput: writeExecSummaryOutput,
-    outputJson: format === "json"
-  });
-}
-
-async function handleFixPlan(args) {
-  const input = getRequiredInput(args, "fix-plan");
-  const format = getFlagValue(args, "--format");
-  const artifact = await createFixPlan(input, { format });
-  return writeOrPrintArtifact({
-    args,
-    commandName: "fix plan",
-    artifact,
-    renderMarkdown: renderFixPlanMarkdown,
-    writeOutput: writeFixPlanOutput,
-    outputJson: format === "json"
-  });
-}
-
-async function handleOwnerBoard(args) {
-  const input = getRequiredInput(args, "owner-board");
-  const format = getFlagValue(args, "--format");
-  const artifact = await createOwnerBoard(input, { format });
-  return writeOrPrintArtifact({
-    args,
-    commandName: "owner board",
-    artifact,
-    renderMarkdown: renderOwnerBoardMarkdown,
-    writeOutput: writeOwnerBoardOutput,
-    outputJson: format === "json"
-  });
-}
-
-async function handleMeetingPack(args) {
-  const input = getRequiredInput(args, "meeting-pack");
-  const format = getFlagValue(args, "--format");
-  const artifact = await createMeetingPack(input, { format });
-  return writeOrPrintArtifact({
-    args,
-    commandName: "meeting pack",
-    artifact,
-    renderMarkdown: renderMeetingPackMarkdown,
-    writeOutput: writeMeetingPackOutput,
-    outputJson: format === "json"
-  });
-}
-
-async function handlePmBrief(args) {
-  const input = getRequiredInput(args, "pm-brief");
-  const format = getFlagValue(args, "--format");
-  const artifact = await createPmBrief(input, { format });
-  return writeOrPrintArtifact({
-    args,
-    commandName: "PM brief",
-    artifact,
-    renderMarkdown: renderPmBriefMarkdown,
-    writeOutput: writePmBriefOutput,
-    outputJson: format === "json"
-  });
-}
-
-async function handleRoadmap(args) {
-  const input = getRequiredInput(args, "roadmap");
-  const format = getFlagValue(args, "--format");
-  const artifact = await createRoadmap(input, { format });
-  return writeOrPrintArtifact({
-    args,
-    commandName: "roadmap",
-    artifact,
-    renderMarkdown: renderRoadmapMarkdown,
-    writeOutput: writeRoadmapOutput,
-    outputJson: format === "json"
-  });
-}
+  })
+});
+
+const handleExecSummary = createArtifactCommandHandler({
+  commandName: "exec-summary",
+  commandLabel: "exec summary",
+  createArtifact: createExecSummary,
+  renderMarkdown: renderExecSummaryMarkdown,
+  writeOutput: writeExecSummaryOutput,
+  getOptions: (args) => ({
+    format: getFlagValue(args, "--format")
+  })
+});
+
+const handleFixPlan = createArtifactCommandHandler({
+  commandName: "fix-plan",
+  commandLabel: "fix plan",
+  createArtifact: createFixPlan,
+  renderMarkdown: renderFixPlanMarkdown,
+  writeOutput: writeFixPlanOutput,
+  getOptions: (args) => ({
+    format: getFlagValue(args, "--format")
+  })
+});
+
+const handleOwnerBoard = createArtifactCommandHandler({
+  commandName: "owner-board",
+  commandLabel: "owner board",
+  createArtifact: createOwnerBoard,
+  renderMarkdown: renderOwnerBoardMarkdown,
+  writeOutput: writeOwnerBoardOutput,
+  getOptions: (args) => ({
+    format: getFlagValue(args, "--format")
+  })
+});
+
+const handleMeetingPack = createArtifactCommandHandler({
+  commandName: "meeting-pack",
+  commandLabel: "meeting pack",
+  createArtifact: createMeetingPack,
+  renderMarkdown: renderMeetingPackMarkdown,
+  writeOutput: writeMeetingPackOutput,
+  getOptions: (args) => ({
+    format: getFlagValue(args, "--format")
+  })
+});
+
+const handlePmBrief = createArtifactCommandHandler({
+  commandName: "pm-brief",
+  commandLabel: "PM brief",
+  createArtifact: createPmBrief,
+  renderMarkdown: renderPmBriefMarkdown,
+  writeOutput: writePmBriefOutput,
+  getOptions: (args) => ({
+    format: getFlagValue(args, "--format")
+  })
+});
+
+const handleRoadmap = createArtifactCommandHandler({
+  commandName: "roadmap",
+  commandLabel: "roadmap",
+  createArtifact: createRoadmap,
+  renderMarkdown: renderRoadmapMarkdown,
+  writeOutput: writeRoadmapOutput,
+  getOptions: (args) => ({
+    format: getFlagValue(args, "--format")
+  })
+});
 
 async function handleReport(args) {
   const input = getRequiredInput(args, "report");

package/src/cli-shared.js

@@ -52,3 +52,41 @@ export async function writeOrPrintArtifact({
 
   process.stdout.write(renderedOutput);
 }
+
+export function createArtifactCommandHandler({
+  commandName,
+  commandLabel,
+  createArtifact,
+  renderMarkdown,
+  writeOutput,
+  getOptions
+}) {
+  return async function artifactCommandHandler(args) {
+    const input = getRequiredInput(args, commandName);
+    const options = getOptions ? getOptions(args) : {};
+    const artifact = await createArtifact(input, options);
+    const outputJson = options.format === "json" || hasFlag(args, "--json");
+
+    return writeOrPrintArtifact({
+      args,
+      commandName: commandLabel,
+      artifact,
+      renderMarkdown,
+      writeOutput,
+      outputJson
+    });
+  };
+}
+
+export function createPackCommandHandler({
+  commandName,
+  writePack,
+  renderMarkdown,
+  getOptions
+}) {
+  return async function packCommandHandler(args) {
+    const input = getRequiredInput(args, commandName);
+    const pack = await writePack(input, getOptions ? getOptions(args) : {});
+    process.stdout.write(renderMarkdown(pack));
+  };
+}