geo-ai-search-optimization 1.3.5 → 1.3.7

package/README.md

@@ -872,6 +872,20 @@ geo-ai-search-optimization help
 - 主 `cli.js` 现在只保留 install / skills / where / version / help 与 command routing
 - CLI 已经形成 `flow / execution / planning-delivery / site-ops / shared` 五层 command adapter 结构
 
+## New in 1.3.6
+
+- 继续做 CLI 架构迭代，把 shell family 也从主 `cli.js` 拆出
+- 新增 `src/cli-shell-commands.js`，接管 `install / skills / where`
+- 主 `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.5",
+  "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));
+  };
+}

package/src/cli-shell-commands.js

@@ -0,0 +1,47 @@
+import { getFlagValue, hasFlag } from "./cli-shared.js";
+import { installSkill } from "./install-skill.js";
+import { getBundledSkillPath, getInstalledSkillPath, getSkillName, getSkillsDir } from "./paths.js";
+import { listBundledSkills, renderBundledSkillsMarkdown } from "./skills.js";
+
+export const SHELL_HELP_LINES = [
+  "  geo-ai-search-optimization install [--target <dir>] [--json]",
+  "  geo-ai-search-optimization skills [--json]",
+  "  geo-ai-search-optimization where"
+];
+
+async function handleInstall(args) {
+  const targetDir = getFlagValue(args, "--target");
+  const outputJson = hasFlag(args, "--json");
+  const result = await installSkill({ targetDir, silent: outputJson });
+
+  if (outputJson) {
+    process.stdout.write(`${JSON.stringify(result, null, 2)}\n`);
+  }
+}
+
+async function handleSkills(args) {
+  const bundle = await listBundledSkills();
+  if (hasFlag(args, "--json")) {
+    process.stdout.write(`${JSON.stringify(bundle, null, 2)}\n`);
+    return;
+  }
+
+  process.stdout.write(renderBundledSkillsMarkdown(bundle));
+}
+
+function handleWhere() {
+  process.stdout.write(
+    [
+      `skill: ${getSkillName()}`,
+      `bundled: ${getBundledSkillPath()}`,
+      `skillsDir: ${getSkillsDir()}`,
+      `installed: ${getInstalledSkillPath()}`
+    ].join("\n") + "\n"
+  );
+}
+
+export const SHELL_COMMAND_HANDLERS = {
+  install: handleInstall,
+  skills: handleSkills,
+  where: handleWhere
+};

package/src/cli.js

@@ -10,11 +10,8 @@ import {
   PLANNING_DELIVERY_COMMAND_HANDLERS,
   PLANNING_DELIVERY_HELP_LINES
 } from "./cli-planning-delivery-commands.js";
+import { SHELL_COMMAND_HANDLERS, SHELL_HELP_LINES } from "./cli-shell-commands.js";
 import { SITE_OPS_COMMAND_HANDLERS, SITE_OPS_HELP_LINES } from "./cli-site-ops-commands.js";
-import { getFlagValue, hasFlag } from "./cli-shared.js";
-import { installSkill } from "./install-skill.js";
-import { getBundledSkillPath, getInstalledSkillPath, getSkillName, getSkillsDir } from "./paths.js";
-import { listBundledSkills, renderBundledSkillsMarkdown } from "./skills.js";
 
 let cachedVersion;
 
@@ -36,13 +33,11 @@ function printHelp() {
       "",
       "Usage:",
       "  geo-ai-search-optimization",
-      "  geo-ai-search-optimization install [--target <dir>] [--json]",
+      ...SHELL_HELP_LINES,
       ...FLOW_HELP_LINES,
       ...AGENT_EXECUTION_HELP_LINES,
       ...PLANNING_DELIVERY_HELP_LINES,
       ...SITE_OPS_HELP_LINES,
-      "  geo-ai-search-optimization skills [--json]",
-      "  geo-ai-search-optimization where",
       "  geo-ai-search-optimization version",
       "  geo-ai-search-optimization help",
       "",
@@ -55,39 +50,9 @@ function printHelp() {
   );
 }
 
-async function handleInstall(args) {
-  const targetDir = getFlagValue(args, "--target");
-  const outputJson = hasFlag(args, "--json");
-  const result = await installSkill({ targetDir, silent: outputJson });
-
-  if (outputJson) {
-    process.stdout.write(`${JSON.stringify(result, null, 2)}\n`);
-  }
-}
-
-function handleWhere() {
-  process.stdout.write(
-    [
-      `skill: ${getSkillName()}`,
-      `bundled: ${getBundledSkillPath()}`,
-      `skillsDir: ${getSkillsDir()}`,
-      `installed: ${getInstalledSkillPath()}`
-    ].join("\n") + "\n"
-  );
-}
-
-async function handleSkills(args) {
-  const bundle = await listBundledSkills();
-  if (hasFlag(args, "--json")) {
-    process.stdout.write(`${JSON.stringify(bundle, null, 2)}\n`);
-    return;
-  }
-
-  process.stdout.write(renderBundledSkillsMarkdown(bundle));
-}
-
 export async function runCli(args = []) {
   const [command = "install", ...rest] = args;
+  const shellHandler = SHELL_COMMAND_HANDLERS[command];
   const flowHandler = FLOW_COMMAND_HANDLERS[command];
   const agentExecutionHandler = AGENT_EXECUTION_COMMAND_HANDLERS[command];
   const planningDeliveryHandler = PLANNING_DELIVERY_COMMAND_HANDLERS[command];
@@ -103,8 +68,8 @@ export async function runCli(args = []) {
     return;
   }
 
-  if (command === "install") {
-    await handleInstall(rest);
+  if (shellHandler) {
+    await shellHandler(rest);
     return;
   }
 
@@ -128,16 +93,6 @@ export async function runCli(args = []) {
     return;
   }
 
-  if (command === "skills") {
-    await handleSkills(rest);
-    return;
-  }
-
-  if (command === "where") {
-    handleWhere();
-    return;
-  }
-
   throw new Error(`Unknown command: ${command}`);
 }