argsbarg 4.0.3 → 4.1.0

package/src/install/targets/completions.ts

@@ -0,0 +1,133 @@
+import { existsSync } from "node:fs";
+import type { CliProgram } from "../../types.ts";
+import { installCompletions, uninstallCompletions } from "../completions.ts";
+import { displayInstallPath, type InstallPaths } from "../paths.ts";
+import { detectShells } from "../shell.ts";
+import { InstallTarget } from "../target-base.ts";
+import type {
+  DetectedSnapshot,
+  InstallAction,
+  InstalledArtifacts,
+  InstallStatus,
+  TargetPlanContext,
+  UninstallAction,
+} from "../target-types.ts";
+
+type ShellKind = "bash" | "zsh" | "fish";
+
+interface ShellCompletionSpec {
+  shell: ShellKind;
+  label: string;
+  path: (paths: InstallPaths) => string;
+  detectedKey: "bashCompletion" | "zshCompletion" | "fishCompletion";
+}
+
+const SHELLS: ShellCompletionSpec[] = [
+  {
+    shell: "bash",
+    label: "bash completion",
+    path: (p) => p.bashCompletion,
+    detectedKey: "bashCompletion",
+  },
+  {
+    shell: "zsh",
+    label: "zsh completion",
+    path: (p) => p.zshCompletion,
+    detectedKey: "zshCompletion",
+  },
+  {
+    shell: "fish",
+    label: "fish completion",
+    path: (p) => p.fishCompletion,
+    detectedKey: "fishCompletion",
+  },
+];
+
+/** Shell tab-completion scripts (bash / zsh / fish). */
+class CompletionsInstallTarget extends InstallTarget {
+  readonly key = "completions" as const;
+  readonly actionKind = "completions" as const;
+  readonly category = "core" as const;
+
+  isAvailable(_root: CliProgram, _paths: InstallPaths): boolean {
+    return true;
+  }
+
+  isDetected(paths: InstallPaths, _root: CliProgram): boolean {
+    return SHELLS.some((s) => existsSync(s.path(paths)));
+  }
+
+  applyDetected(paths: InstallPaths, _root: CliProgram, out: InstalledArtifacts): void {
+    for (const s of SHELLS) {
+      out[s.detectedKey] = existsSync(s.path(paths));
+    }
+  }
+
+  protected isDetectedFromSnapshot(detected: DetectedSnapshot): boolean {
+    return detected.bashCompletion || detected.zshCompletion || detected.fishCompletion;
+  }
+
+  protected formatStatusLine(_paths: InstallPaths, _root: CliProgram): string {
+    return "";
+  }
+
+  protected assignStatusLine(_status: InstallStatus, _line: string): void {}
+
+  contributeStatus(
+    paths: InstallPaths,
+    _root: CliProgram,
+    detected: InstalledArtifacts,
+    status: InstallStatus,
+  ): void {
+    if (detected.bashCompletion) {
+      status.bashCompletion = displayInstallPath(paths.bashCompletion);
+    }
+    if (detected.zshCompletion) {
+      status.zshCompletion = displayInstallPath(paths.zshCompletion);
+    }
+    if (detected.fishCompletion) {
+      status.fishCompletion = displayInstallPath(paths.fishCompletion);
+    }
+  }
+
+  protected buildInstallActions(ctx: TargetPlanContext): InstallAction[] {
+    const shells = detectShells();
+    const actions: InstallAction[] = [];
+    const refresh = ctx.mode === "refresh";
+
+    for (const s of SHELLS) {
+      const onPath = shells[s.shell];
+      const path = s.path(ctx.paths);
+      const wasInstalled = ctx.detected[s.detectedKey];
+      if (!onPath || (refresh && !wasInstalled)) continue;
+
+      actions.push({
+        kind: "completions",
+        summary: `${s.label}: ${displayInstallPath(path)}`,
+        message: `Writing ${s.label} to ${displayInstallPath(path)}`,
+        run: () => {
+          const all = installCompletions(ctx.root, ctx.paths, ctx.dry);
+          return all.filter((p) => p === path);
+        },
+      });
+    }
+    return actions;
+  }
+
+  protected buildUninstallActions(ctx: TargetPlanContext): UninstallAction[] {
+    const actions: UninstallAction[] = [];
+    for (const s of SHELLS) {
+      if (!ctx.detected[s.detectedKey]) continue;
+      const path = s.path(ctx.paths);
+      actions.push({
+        kind: "completions",
+        summary: `${s.label}: ${displayInstallPath(path)}`,
+        message: `Removing ${s.label} ${displayInstallPath(path)}`,
+        run: () => uninstallCompletions(ctx.paths, ctx.dry).filter((p) => p === path),
+      });
+    }
+    return actions;
+  }
+}
+
+export const completionsTarget = new CompletionsInstallTarget();

package/src/install/targets/configure.ts

@@ -0,0 +1,59 @@
+import { appConfigInstalled, displayAppConfigPath, uninstallAppConfig } from "../../config/file.ts";
+import type { CliProgram } from "../../types.ts";
+import type { InstallPaths } from "../paths.ts";
+import { InstallTarget } from "../target-base.ts";
+import type {
+  DetectedSnapshot,
+  InstallAction,
+  InstalledArtifacts,
+  InstallStatus,
+  TargetPlanContext,
+  UninstallAction,
+} from "../target-types.ts";
+
+/** App config file (install --configure / wizard). */
+class ConfigureInstallTarget extends InstallTarget {
+  readonly key = "configure" as const;
+  readonly actionKind = "configure" as const;
+  readonly category = "core" as const;
+
+  isAvailable(root: CliProgram, _paths: InstallPaths): boolean {
+    return root.appConfig !== undefined;
+  }
+
+  isDetected(_paths: InstallPaths, root: CliProgram): boolean {
+    if (!root.appConfig) return false;
+    return appConfigInstalled(root);
+  }
+
+  applyDetected(_paths: InstallPaths, _root: CliProgram, _out: InstalledArtifacts): void {}
+
+  protected isDetectedFromSnapshot(detected: DetectedSnapshot): boolean {
+    return detected.appConfig ?? false;
+  }
+
+  protected formatStatusLine(_paths: InstallPaths, root: CliProgram): string {
+    return displayAppConfigPath(root);
+  }
+
+  protected assignStatusLine(_status: InstallStatus, _line: string): void {
+    // configure status shown via appConfigStatus in status.ts
+  }
+
+  protected buildInstallActions(_ctx: TargetPlanContext): InstallAction[] {
+    return [];
+  }
+
+  protected buildUninstallActions(ctx: TargetPlanContext): UninstallAction[] {
+    return [
+      {
+        kind: "configure",
+        summary: `app config: ${displayAppConfigPath(ctx.root)}`,
+        message: `Removing app config ${displayAppConfigPath(ctx.root)}`,
+        run: () => uninstallAppConfig(ctx.root, ctx.dry),
+      },
+    ];
+  }
+}
+
+export const configureTarget = new ConfigureInstallTarget();

package/src/install/targets/cursor-mcp.ts

@@ -0,0 +1,15 @@
+import { existsSync } from "node:fs";
+import { join } from "node:path";
+import { userHome } from "../paths.ts";
+import { McpJsonInstallTarget } from "../target-mcp-json.ts";
+
+export const cursorMcpTarget = new McpJsonInstallTarget({
+  key: "cursorMcp",
+  actionKind: "cursor-mcp",
+  label: "cursor mcp",
+  pairedSkillKey: "cursorSkill",
+  configPath: (p) => p.cursorMcpPath,
+  detectedKey: "cursorMcp",
+  statusField: "cursorMcp",
+  isAvailable: () => existsSync(join(userHome(), ".cursor")),
+});

package/src/install/targets/cursor-skill.ts

@@ -0,0 +1,16 @@
+import { existsSync } from "node:fs";
+import { join } from "node:path";
+import { userHome } from "../paths.ts";
+import { SkillInstallTarget } from "../target-skill.ts";
+
+export const cursorSkillTarget = new SkillInstallTarget({
+  key: "cursorSkill",
+  actionKind: "cursor-skill",
+  label: "Cursor",
+  uninstallPrefix: "cursor skill",
+  pairedMcpKey: "cursorMcp",
+  skillDir: (p) => p.cursorSkillDir,
+  detectedKey: "cursorSkill",
+  statusField: "cursorSkill",
+  isAvailable: () => existsSync(join(userHome(), ".cursor")),
+});

package/src/install/targets/index.ts

@@ -0,0 +1,53 @@
+import type { InstallTarget } from "../target-base.ts";
+import { appTarget } from "./app.ts";
+import { chatgptMcpTarget } from "./chatgpt-mcp.ts";
+import { claudeCodeMcpTarget } from "./claude-code-mcp.ts";
+import { claudeDesktopMcpTarget } from "./claude-desktop-mcp.ts";
+import { claudeSkillTarget } from "./claude-skill.ts";
+import { codexMcpTarget } from "./codex-mcp.ts";
+import { codexSkillTarget } from "./codex-skill.ts";
+import { completionsTarget } from "./completions.ts";
+import { configureTarget } from "./configure.ts";
+import { cursorMcpTarget } from "./cursor-mcp.ts";
+import { cursorSkillTarget } from "./cursor-skill.ts";
+import { openclawMcpTarget } from "./openclaw-mcp.ts";
+import { openclawSkillTarget } from "./openclaw-skill.ts";
+import { opencodeMcpTarget } from "./opencode-mcp.ts";
+import { opencodeSkillTarget } from "./opencode-skill.ts";
+
+/** Ordered install targets (plan iteration order). */
+export const INSTALL_TARGETS: InstallTarget[] = [
+  appTarget,
+  completionsTarget,
+  cursorSkillTarget,
+  claudeSkillTarget,
+  codexSkillTarget,
+  opencodeSkillTarget,
+  openclawSkillTarget,
+  cursorMcpTarget,
+  claudeCodeMcpTarget,
+  claudeDesktopMcpTarget,
+  opencodeMcpTarget,
+  codexMcpTarget,
+  openclawMcpTarget,
+  chatgptMcpTarget,
+  configureTarget,
+];
+
+export {
+  appTarget,
+  chatgptMcpTarget,
+  claudeCodeMcpTarget,
+  claudeDesktopMcpTarget,
+  claudeSkillTarget,
+  codexMcpTarget,
+  codexSkillTarget,
+  completionsTarget,
+  configureTarget,
+  cursorMcpTarget,
+  cursorSkillTarget,
+  openclawMcpTarget,
+  openclawSkillTarget,
+  opencodeMcpTarget,
+  opencodeSkillTarget,
+};

package/src/install/targets/openclaw-mcp.ts

@@ -0,0 +1,25 @@
+import { openclawOnPath } from "../mcp-openclaw.ts";
+import {
+  checkOpenclawMcpConflict,
+  McpCliInstallTarget,
+  mergeOpenclawMcpConfig,
+  openclawMcpHasServer,
+  removeOpenclawMcpConfig,
+} from "../target-mcp-cli.ts";
+
+export const openclawMcpTarget = new McpCliInstallTarget({
+  key: "openclawMcp",
+  actionKind: "openclaw-mcp",
+  label: "openclaw mcp",
+  pairedSkillKey: "openclawSkill",
+  configPath: (p) => p.openclawConfigPath,
+  detectedKey: "openclawMcp",
+  statusField: "openclawMcp",
+  isAvailable: () => openclawOnPath(),
+  hasServer: openclawMcpHasServer,
+  installMessage: 'Registering MCP server "{name}" via openclaw mcp add',
+  uninstallMessage: 'Removing MCP server "{name}" from OpenClaw via openclaw mcp unset',
+  merge: mergeOpenclawMcpConfig,
+  remove: removeOpenclawMcpConfig,
+  preflight: checkOpenclawMcpConflict,
+});

package/src/install/targets/openclaw-skill.ts

@@ -0,0 +1,17 @@
+import { existsSync } from "node:fs";
+import { join } from "node:path";
+import { openclawOnPath } from "../mcp-openclaw.ts";
+import { userHome } from "../paths.ts";
+import { SkillInstallTarget } from "../target-skill.ts";
+
+export const openclawSkillTarget = new SkillInstallTarget({
+  key: "openclawSkill",
+  actionKind: "openclaw-skill",
+  label: "OpenClaw",
+  uninstallPrefix: "openclaw skill",
+  pairedMcpKey: "openclawMcp",
+  skillDir: (p) => p.openclawSkillDir,
+  detectedKey: "openclawSkill",
+  statusField: "openclawSkill",
+  isAvailable: () => existsSync(join(userHome(), ".openclaw")) || openclawOnPath(),
+});

package/src/install/targets/opencode-mcp.ts

@@ -0,0 +1,101 @@
+import type { CliProgram } from "../../types.ts";
+import {
+  checkOpenCodeMcpConflict,
+  detectOpenCodeMcpConfigPath,
+  expectedOpenCodeMcpEntry,
+  mergeOpenCodeMcpConfig,
+  opencodePresent,
+  removeOpenCodeMcpConfig,
+} from "../mcp-opencode.ts";
+import { displayInstallPath, type InstallPaths, userHome } from "../paths.ts";
+import { InstallTarget } from "../target-base.ts";
+import type {
+  DetectedSnapshot,
+  InstallAction,
+  InstalledArtifacts,
+  InstallStatus,
+  TargetPlanContext,
+  UninstallAction,
+} from "../target-types.ts";
+
+function resolveConfigPath(paths: InstallPaths, home: string): string {
+  return detectOpenCodeMcpConfigPath(home, paths.mcpName) ?? paths.opencodeMcpPath;
+}
+
+/** OpenCode MCP (top-level `mcp` key, not `mcpServers`). */
+class OpenCodeMcpInstallTarget extends InstallTarget {
+  readonly key = "opencodeMcp" as const;
+  readonly actionKind = "opencode-mcp" as const;
+  readonly category = "mcp" as const;
+  readonly pairedKey = "opencodeSkill" as const;
+
+  isAvailable(_root: CliProgram, _paths: InstallPaths): boolean {
+    return opencodePresent(userHome());
+  }
+
+  isDetected(paths: InstallPaths, _root: CliProgram): boolean {
+    return detectOpenCodeMcpConfigPath(userHome(), paths.mcpName) !== undefined;
+  }
+
+  applyDetected(paths: InstallPaths, root: CliProgram, out: InstalledArtifacts): void {
+    out.opencodeMcp = this.isDetected(paths, root);
+  }
+
+  protected isDetectedFromSnapshot(detected: DetectedSnapshot): boolean {
+    return detected.opencodeMcp;
+  }
+
+  protected formatStatusLine(paths: InstallPaths, _root: CliProgram): string {
+    const home = userHome();
+    const path = detectOpenCodeMcpConfigPath(home, paths.mcpName) ?? paths.opencodeMcpPath;
+    return `${displayInstallPath(path)} (server "${paths.mcpName}")`;
+  }
+
+  protected assignStatusLine(status: InstallStatus, line: string): void {
+    status.opencodeMcp = line;
+  }
+
+  preflight(ctx: TargetPlanContext): string | null {
+    const entry = expectedOpenCodeMcpEntry(ctx.root);
+    return checkOpenCodeMcpConflict(
+      ctx.paths.opencodeMcpPath,
+      ctx.paths.mcpName,
+      entry,
+      !!ctx.opts.yes,
+    );
+  }
+
+  protected buildInstallActions(ctx: TargetPlanContext): InstallAction[] {
+    const entry = expectedOpenCodeMcpEntry(ctx.root);
+    const configPath = ctx.paths.opencodeMcpPath;
+    return [
+      {
+        kind: this.actionKind,
+        summary: `opencode mcp: ${displayInstallPath(configPath)}`,
+        message: `Merging MCP server "${ctx.paths.mcpName}" into ${displayInstallPath(configPath)}`,
+        run: () => {
+          mergeOpenCodeMcpConfig(configPath, ctx.paths.mcpName, entry, ctx.dry);
+          return [configPath];
+        },
+      },
+    ];
+  }
+
+  protected buildUninstallActions(ctx: TargetPlanContext): UninstallAction[] {
+    const home = userHome();
+    const configPath = resolveConfigPath(ctx.paths, home);
+    return [
+      {
+        kind: this.actionKind,
+        summary: `opencode mcp: ${displayInstallPath(configPath)}`,
+        message: `Removing MCP server "${ctx.paths.mcpName}" from ${displayInstallPath(configPath)}`,
+        run: () => {
+          removeOpenCodeMcpConfig(configPath, ctx.paths.mcpName, ctx.dry);
+          return [configPath];
+        },
+      },
+    ];
+  }
+}
+
+export const opencodeMcpTarget = new OpenCodeMcpInstallTarget();

package/src/install/targets/opencode-skill.ts

@@ -0,0 +1,15 @@
+import { opencodePresent } from "../mcp-opencode.ts";
+import { userHome } from "../paths.ts";
+import { SkillInstallTarget } from "../target-skill.ts";
+
+export const opencodeSkillTarget = new SkillInstallTarget({
+  key: "opencodeSkill",
+  actionKind: "opencode-skill",
+  label: "OpenCode",
+  uninstallPrefix: "opencode skill",
+  pairedMcpKey: "opencodeMcp",
+  skillDir: (p) => p.opencodeSkillDir,
+  detectedKey: "opencodeSkill",
+  statusField: "opencodeSkill",
+  isAvailable: () => opencodePresent(userHome()),
+});

package/src/install/targets.test.ts

@@ -0,0 +1,136 @@
+import { describe, expect, test } from "bun:test";
+import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import type { CliProgram } from "../types.ts";
+import { maybeBootstrapInstallArgv } from "./bootstrap.ts";
+import { normalizeInstallRawOpts } from "./normalize.ts";
+import { resolveInstallPaths } from "./paths.ts";
+import { resolveAgentIntegration, resolveEffectiveInstallTargets } from "./target-effective.ts";
+import { isArtifactInScope } from "./target-scope.ts";
+
+describe("normalizeInstallRawOpts", () => {
+  test("bare install sets all", () => {
+    expect(normalizeInstallRawOpts({})).toEqual({ all: "1" });
+  });
+
+  test("bare uninstall sets all", () => {
+    expect(normalizeInstallRawOpts({ uninstall: "1" })).toEqual({
+      uninstall: "1",
+      all: "1",
+    });
+  });
+
+  test("configure-only install unchanged", () => {
+    expect(normalizeInstallRawOpts({ configure: "1" })).toEqual({ configure: "1" });
+  });
+});
+
+describe("resolveAgentIntegration", () => {
+  test("defaults to skill without MCP", () => {
+    expect(resolveAgentIntegration(undefined, false)).toBe("skill");
+  });
+
+  test("defaults to mcp when MCP enabled", () => {
+    expect(resolveAgentIntegration(undefined, true)).toBe("mcp");
+  });
+});
+
+describe("resolveEffectiveInstallTargets", () => {
+  test("defaults app completions configure includedInAll", () => {
+    const t = resolveEffectiveInstallTargets(undefined);
+    expect(t.app.includedInAll).toBe(true);
+    expect(t.completions.includedInAll).toBe(true);
+    expect(t.configure.includedInAll).toBe(true);
+  });
+
+  test("skill mode includes skills in --all not MCP pairs", () => {
+    const program: Pick<CliProgram, "mcpServer"> = {};
+    const t = resolveEffectiveInstallTargets(undefined, program);
+    expect(t.cursorSkill.includedInAll).toBe(true);
+    expect(t.cursorMcp.includedInAll).toBe(false);
+  });
+
+  test("mcp mode includes MCP in --all not paired skills", () => {
+    const program: Pick<CliProgram, "mcpServer"> = { mcpServer: { enabled: true } };
+    const t = resolveEffectiveInstallTargets(undefined, program);
+    expect(t.cursorMcp.includedInAll).toBe(true);
+    expect(t.cursorSkill.includedInAll).toBe(false);
+    expect(t.claudeDesktopMcp.includedInAll).toBe(true);
+  });
+
+  test("both mode includes MCP and skills", () => {
+    const program: Pick<CliProgram, "mcpServer"> = { mcpServer: { enabled: true } };
+    const t = resolveEffectiveInstallTargets({ agentIntegration: "both" }, program);
+    expect(t.cursorMcp.includedInAll).toBe(true);
+    expect(t.cursorSkill.includedInAll).toBe(true);
+  });
+
+  test("per-key override disables one skill", () => {
+    const t = resolveEffectiveInstallTargets({
+      targets: { cursorSkill: false },
+    });
+    expect(t.claudeSkill.includedInAll).toBe(true);
+    expect(t.cursorSkill.enabled).toBe(false);
+  });
+
+  test("scoped --mcp uses effective targets not all MCP hosts", () => {
+    const program: CliProgram = {
+      key: "app",
+      version: "1",
+      description: "x",
+      mcpServer: { enabled: true },
+      install: { agentIntegration: "skill" },
+      handler: () => {},
+    };
+    const effective = resolveEffectiveInstallTargets(program.install, program);
+    const scope = { mcp: true };
+    expect(isArtifactInScope("cursorMcp", scope, effective, "install-scoped", program)).toBe(false);
+    expect(
+      isArtifactInScope(
+        "cursorMcp",
+        scope,
+        resolveEffectiveInstallTargets(
+          { targets: { cursorMcp: true }, agentIntegration: "both" },
+          program,
+        ),
+        "install-scoped",
+        program,
+      ),
+    ).toBe(true);
+  });
+});
+
+describe("maybeBootstrapInstallArgv", () => {
+  const program: CliProgram = {
+    key: "bootapp",
+    version: "1.0.0",
+    description: "Boot",
+    handler: () => {},
+  };
+
+  test("rewrites empty argv when app missing and TTY", () => {
+    const prev = process.stdin.isTTY;
+    Object.defineProperty(process.stdin, "isTTY", { value: true, configurable: true });
+    try {
+      expect(maybeBootstrapInstallArgv([], program)).toEqual(["install"]);
+    } finally {
+      Object.defineProperty(process.stdin, "isTTY", { value: prev, configurable: true });
+    }
+  });
+
+  test("does not rewrite when app exists", () => {
+    const home = mkdtempSync(join(tmpdir(), "boot-"));
+    const prevHome = process.env.HOME;
+    process.env.HOME = home;
+    const paths = resolveInstallPaths(program);
+    try {
+      mkdirSync(paths.appDir, { recursive: true });
+      writeFileSync(paths.appPath, "x", "utf8");
+      expect(maybeBootstrapInstallArgv([], program)).toEqual([]);
+    } finally {
+      process.env.HOME = prevHome;
+      rmSync(home, { recursive: true, force: true });
+    }
+  });
+});