argsbarg 4.0.3 → 4.1.0

package/src/install/plan.ts

@@ -1,282 +1,53 @@
-import { existsSync } from "node:fs";
-import { join } from "node:path";
 import { resolveCapabilities } from "../capabilities.ts";
 import type { CliProgram } from "../types.ts";
-import { installBinary } from "./binary.ts";
-import { installCompletions } from "./completions.ts";
-import { detectInstalledArtifacts } from "./detect-installed.ts";
-import { codexOnPath, mergeCodexMcpConfig } from "./mcp-codex.ts";
-import { expectedMcpEntry, mergeMcpConfig } from "./mcp-config.ts";
-import {
-  expectedOpenCodeMcpEntry,
-  mergeOpenCodeMcpConfig,
-  opencodePresent,
-} from "./mcp-opencode.ts";
-import {
-  chatGptDesktopPresent,
-  claudeDesktopPresent,
-  type InstallPaths,
-  userHome,
-} from "./paths.ts";
-import { detectShells } from "./shell.ts";
+import type { InstallPaths } from "./paths.ts";
+import { buildInstallPlanFromTargets } from "./target-plan-build.ts";
+import type { InstallAction, InstallOpts } from "./target-types.ts";
 
-export interface InstallOpts {
-  all?: boolean;
-  bin?: boolean;
-  completions?: boolean;
-  skill?: boolean;
-  mcp?: boolean;
-  reinstall?: boolean;
-  update?: boolean;
-  from?: string;
-  status?: boolean;
-  uninstall?: boolean;
-  configure?: boolean;
-  config?: boolean;
-  yes?: boolean;
-  dry?: boolean;
-  json?: boolean;
-  quiet?: boolean;
-  prefix?: string;
-}
+export type { InstallAction, InstallActionKind, InstallOpts } from "./target-types.ts";
 
-export type InstallActionKind =
-  | "binary"
-  | "completions"
-  | "cursor-skill"
-  | "claude-skill"
-  | "cursor-mcp"
-  | "claude-mcp"
-  | "claude-desktop-mcp"
-  | "opencode-mcp"
-  | "codex-mcp"
-  | "chatgpt-desktop-mcp";
+/** Builds install actions for normal mode (--all / scoped targets). */
+export function buildInstallPlan(
+  root: CliProgram,
+  paths: InstallPaths,
+  opts: InstallOpts,
+): InstallAction[] {
+  return buildInstallPlanFromTargets(root, paths, opts);
+}
 
-export interface InstallAction {
-  kind: InstallActionKind;
-  summary: string;
-  message: string;
-  run: () => string[];
+/** Builds update/reinstall actions for detected artifacts within effective targets. */
+export function buildUpdatePlan(
+  root: CliProgram,
+  paths: InstallPaths,
+  opts: InstallOpts,
+): InstallAction[] {
+  return buildInstallPlan(root, paths, { ...opts, reinstall: true, all: true });
 }
 
-export function wantsInstallBin(opts: InstallOpts): boolean {
-  return !!(opts.all || opts.bin || opts.reinstall);
+/** @deprecated Use resolveInstallPlanMode + shouldIncludeArtifact. */
+export function wantsInstallApp(opts: InstallOpts): boolean {
+  return !!(opts.all || opts.app || opts.reinstall);
 }
 
+/** @deprecated Use {@link wantsInstallApp}. */
+export const wantsInstallBin = wantsInstallApp;
+
+/** @deprecated Use resolveInstallPlanMode + shouldIncludeArtifact. */
 export function wantsInstallCompletions(opts: InstallOpts): boolean {
   return !!(opts.all || opts.completions);
 }
 
+/** @deprecated Use resolveInstallPlanMode + shouldIncludeArtifact. */
 export function wantsInstallSkill(opts: InstallOpts): boolean {
   return !!(opts.all || opts.skill);
 }
 
+/** @deprecated Use resolveInstallPlanMode + shouldIncludeArtifact. */
 export function wantsInstallMcp(opts: InstallOpts, root: CliProgram): boolean {
   return !!(opts.mcp || opts.all) && resolveCapabilities(root).mcp;
 }
 
+/** @deprecated Use configure target + shouldIncludeArtifact. */
 export function wantsUninstallConfig(opts: InstallOpts, root: CliProgram): boolean {
-  return !!(opts.config || opts.all) && root.appConfig !== undefined;
-}
-
-/** Builds install actions for normal mode (--all / scoped targets). */
-export function buildInstallPlan(
-  root: CliProgram,
-  paths: InstallPaths,
-  opts: InstallOpts,
-): InstallAction[] {
-  const actions: InstallAction[] = [];
-  const dry = !!opts.dry;
-
-  if (wantsInstallBin(opts)) {
-    const sourcePath = opts.from ?? process.execPath;
-    actions.push({
-      kind: "binary",
-      summary: `binary: ${paths.binaryPath}`,
-      message: `Installing binary to ${paths.binaryPath}`,
-      run: () => installBinary(root, paths, dry, sourcePath).changedFiles,
-    });
-  }
-
-  if (wantsInstallCompletions(opts)) {
-    const shells = detectShells();
-    if (shells.bash) {
-      actions.push({
-        kind: "completions",
-        summary: `bash completion: ${paths.bashCompletion}`,
-        message: `Writing bash completion to ${paths.bashCompletion}`,
-        run: () => {
-          const all = installCompletions(root, paths, dry);
-          return all.filter((p) => p === paths.bashCompletion);
-        },
-      });
-    }
-    if (shells.zsh) {
-      actions.push({
-        kind: "completions",
-        summary: `zsh completion: ${paths.zshCompletion}`,
-        message: `Writing zsh completion to ${paths.zshCompletion}`,
-        run: () => {
-          const all = installCompletions(root, paths, dry);
-          return all.filter((p) => p === paths.zshCompletion);
-        },
-      });
-    }
-    if (shells.fish) {
-      actions.push({
-        kind: "completions",
-        summary: `fish completion: ${paths.fishCompletion}`,
-        message: `Writing fish completion to ${paths.fishCompletion}`,
-        run: () => {
-          const all = installCompletions(root, paths, dry);
-          return all.filter((p) => p === paths.fishCompletion);
-        },
-      });
-    }
-  }
-
-  if (wantsInstallSkill(opts)) {
-    const home = userHome();
-    if (existsSync(join(home, ".cursor"))) {
-      actions.push({
-        kind: "cursor-skill",
-        summary: `cursor skill: ${paths.cursorSkillDir}/`,
-        message: `Installing Cursor skill to ${paths.cursorSkillDir}/`,
-        run: () => [],
-      });
-    }
-    if (existsSync(join(home, ".claude"))) {
-      actions.push({
-        kind: "claude-skill",
-        summary: `claude skill: ${paths.claudeSkillDir}/`,
-        message: `Installing Claude Code skill to ${paths.claudeSkillDir}/`,
-        run: () => [],
-      });
-    }
-  }
-
-  if (wantsInstallMcp(opts, root)) {
-    const entry = expectedMcpEntry(root);
-    if (existsSync(join(userHome(), ".cursor"))) {
-      actions.push({
-        kind: "cursor-mcp",
-        summary: `cursor mcp: ${paths.cursorMcpPath} (server "${paths.mcpName}")`,
-        message: `Merging MCP server "${paths.mcpName}" into ${paths.cursorMcpPath}`,
-        run: () => {
-          mergeMcpConfig(paths.cursorMcpPath, paths.mcpName, entry, dry);
-          return [paths.cursorMcpPath];
-        },
-      });
-    }
-    actions.push({
-      kind: "claude-mcp",
-      summary: `claude code mcp: ${paths.claudeMcpPath} (server "${paths.mcpName}")`,
-      message: `Merging MCP server "${paths.mcpName}" into ${paths.claudeMcpPath}`,
-      run: () => {
-        mergeMcpConfig(paths.claudeMcpPath, paths.mcpName, entry, dry);
-        return [paths.claudeMcpPath];
-      },
-    });
-    if (claudeDesktopPresent(userHome(), paths.claudeDesktopMcpPath)) {
-      actions.push({
-        kind: "claude-desktop-mcp",
-        summary: `claude desktop mcp: ${paths.claudeDesktopMcpPath} (server "${paths.mcpName}")`,
-        message: `Merging MCP server "${paths.mcpName}" into ${paths.claudeDesktopMcpPath}`,
-        run: () => {
-          mergeMcpConfig(paths.claudeDesktopMcpPath, paths.mcpName, entry, dry);
-          return [paths.claudeDesktopMcpPath];
-        },
-      });
-    }
-    if (opencodePresent(userHome())) {
-      const openCodeEntry = expectedOpenCodeMcpEntry(root);
-      actions.push({
-        kind: "opencode-mcp",
-        summary: `opencode mcp: ${paths.opencodeMcpPath} (server "${paths.mcpName}")`,
-        message: `Merging MCP server "${paths.mcpName}" into ${paths.opencodeMcpPath}`,
-        run: () => {
-          mergeOpenCodeMcpConfig(paths.opencodeMcpPath, paths.mcpName, openCodeEntry, dry);
-          return [paths.opencodeMcpPath];
-        },
-      });
-    }
-    if (codexOnPath()) {
-      actions.push({
-        kind: "codex-mcp",
-        summary: `codex mcp: ${paths.codexConfigPath} (server "${paths.mcpName}")`,
-        message: `Registering MCP server "${paths.mcpName}" via codex mcp add`,
-        run: () => {
-          const configPath = mergeCodexMcpConfig(userHome(), paths.mcpName, entry, dry, !!opts.yes);
-          return [configPath];
-        },
-      });
-    }
-    if (chatGptDesktopPresent(userHome(), paths.chatGptMcpPath)) {
-      actions.push({
-        kind: "chatgpt-desktop-mcp",
-        summary: `chatgpt desktop mcp: ${paths.chatGptMcpPath} (server "${paths.mcpName}")`,
-        message: `Merging MCP server "${paths.mcpName}" into ${paths.chatGptMcpPath}`,
-        run: () => {
-          mergeMcpConfig(paths.chatGptMcpPath, paths.mcpName, entry, dry);
-          return [paths.chatGptMcpPath];
-        },
-      });
-    }
-  }
-
-  return actions;
-}
-
-/** Builds update actions for artifacts already installed. */
-export function buildUpdatePlan(
-  root: CliProgram,
-  paths: InstallPaths,
-  opts: InstallOpts,
-): InstallAction[] {
-  const detected = detectInstalledArtifacts(paths);
-  const scoped: InstallOpts = {
-    bin: true,
-    completions: detected.bashCompletion || detected.zshCompletion || detected.fishCompletion,
-    skill: detected.cursorSkill || detected.claudeSkill,
-    mcp:
-      (detected.cursorMcp ||
-        detected.claudeMcp ||
-        detected.claudeDesktopMcp ||
-        detected.opencodeMcp ||
-        detected.codexMcp ||
-        detected.chatGptMcp) &&
-      resolveCapabilities(root).mcp,
-    dry: opts.dry,
-  };
-  const plan = buildInstallPlan(root, paths, scoped);
-
-  return plan.filter((action) => {
-    switch (action.kind) {
-      case "binary":
-        return true;
-      case "completions":
-        if (action.summary.startsWith("bash")) return detected.bashCompletion;
-        if (action.summary.startsWith("zsh")) return detected.zshCompletion;
-        if (action.summary.startsWith("fish")) return detected.fishCompletion;
-        return false;
-      case "cursor-skill":
-        return detected.cursorSkill;
-      case "claude-skill":
-        return detected.claudeSkill;
-      case "cursor-mcp":
-        return detected.cursorMcp;
-      case "claude-mcp":
-        return detected.claudeMcp;
-      case "claude-desktop-mcp":
-        return detected.claudeDesktopMcp;
-      case "opencode-mcp":
-        return detected.opencodeMcp;
-      case "codex-mcp":
-        return detected.codexMcp;
-      case "chatgpt-desktop-mcp":
-        return detected.chatGptMcp;
-      default:
-        return false;
-    }
-  });
+  return !!(opts.configure || opts.all) && root.appConfig !== undefined;
 }

package/src/install/shell.ts

@@ -22,10 +22,10 @@ export function rcMarkerEnd(appKey: string, tag: string): string {
 }
 
 /** Returns rc snippet block for PATH, or null if already present. */
-export function buildPathRcBlock(appKey: string, bindir: string): string {
+export function buildPathRcBlock(appKey: string, appDir: string): string {
   const start = rcMarkerStart(appKey, "path");
   const end = rcMarkerEnd(appKey, "path");
-  return [start, `export PATH="${bindir}:$PATH"`, end].join("\n");
+  return [start, `export PATH="${appDir}:$PATH"`, end].join("\n");
 }
 
 /** Returns rc snippet block for zsh fpath, or null if already present. */

package/src/install/status.test.ts

@@ -0,0 +1,85 @@
+import { afterEach, beforeEach, describe, expect, test } from "bun:test";
+import { mkdtempSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import type { CliProgram } from "../types.ts";
+import { resolveInstallPaths } from "./paths.ts";
+import { printInstallStatus } from "./status.ts";
+import { resolveInstallTargetPreview } from "./target-scope.ts";
+
+let home: string;
+let prevHome: string | undefined;
+
+beforeEach(() => {
+  home = mkdtempSync(join(tmpdir(), "argsbarg-status-"));
+  prevHome = process.env.HOME;
+  process.env.HOME = home;
+});
+
+afterEach(() => {
+  if (prevHome === undefined) delete process.env.HOME;
+  else process.env.HOME = prevHome;
+  rmSync(home, { recursive: true, force: true });
+});
+
+describe("resolveInstallTargetPreview", () => {
+  test("mcp app previews MCP keys for all and mcp scopes", () => {
+    const program: CliProgram = {
+      key: "mcpapp",
+      version: "1",
+      description: "x",
+      mcpServer: { enabled: true },
+      handler: () => {},
+    };
+    const paths = resolveInstallPaths(program);
+    const preview = resolveInstallTargetPreview(program, paths);
+    expect(preview.agentIntegration).toBe("mcp");
+    expect(preview.all).toContain("app");
+    expect(preview.all).toContain("completions");
+    expect(preview.skill).toEqual([]);
+  });
+
+  test("shell app previews skill keys", () => {
+    const program: CliProgram = {
+      key: "cliapp",
+      version: "1",
+      description: "x",
+      handler: () => {},
+    };
+    const paths = resolveInstallPaths(program);
+    const preview = resolveInstallTargetPreview(program, paths);
+    expect(preview.agentIntegration).toBe("skill");
+    expect(preview.all).toContain("app");
+    expect(preview.mcp).toEqual([]);
+  });
+});
+
+describe("printInstallStatus json", () => {
+  test("includes agentIntegration and effective scopes", () => {
+    const program: CliProgram = {
+      key: "app",
+      version: "1",
+      description: "x",
+      mcpServer: { enabled: true },
+      handler: () => {},
+    };
+    const chunks: string[] = [];
+    const orig = process.stdout.write;
+    process.stdout.write = ((chunk: string | Uint8Array) => {
+      chunks.push(typeof chunk === "string" ? chunk : Buffer.from(chunk).toString("utf8"));
+      return true;
+    }) as typeof process.stdout.write;
+    try {
+      printInstallStatus(program, { json: true });
+      const parsed = JSON.parse(chunks.join("")) as {
+        agentIntegration: string;
+        effective: { all: string[]; mcp: string[]; skill: string[] };
+      };
+      expect(parsed.agentIntegration).toBe("mcp");
+      expect(parsed.effective.all).toContain("app");
+      expect(Array.isArray(parsed.effective.skill)).toBe(true);
+    } finally {
+      process.stdout.write = orig;
+    }
+  });
+});

package/src/install/status.ts

@@ -2,15 +2,15 @@ import { appConfigStatus } from "../config/bootstrap.ts";
 import type { CliProgram } from "../types.ts";
 import { buildInstallStatus, detectInstalledArtifacts } from "./detect-installed.ts";
 import { resolveInstallPaths } from "./paths.ts";
-import type { InstallOpts } from "./plan.ts";
+import { resolveInstallTargetPreview } from "./target-scope.ts";
+import type { InstallOpts } from "./target-types.ts";
 
 export function installOut(msg: string, opts: InstallOpts): void {
-  if (opts.quiet || opts.json) return;
+  if (opts.json) return;
   process.stdout.write(`${msg}\n`);
 }
 
 export function installInfo(msg: string, opts: InstallOpts): void {
-  if (opts.quiet) return;
   if (opts.json && !opts.dry) return;
   const prefix = opts.dry ? "[dry run] " : "";
   process.stderr.write(`${prefix + msg}\n`);
@@ -20,15 +20,28 @@ export function installErr(msg: string): void {
   process.stderr.write(`${msg}\n`);
 }
 
+/** Interactive install/uninstall banner (stderr; leading blank line). */
+export function writeInteractiveInstallIntro(root: CliProgram): void {
+  process.stderr.write(`\n${root.key} Setup\n\n`);
+}
+
 /** Prints install status to stdout (human or JSON). */
 export function printInstallStatus(root: CliProgram, opts: InstallOpts): void {
-  const paths = resolveInstallPaths(root, opts);
-  const detected = detectInstalledArtifacts(paths);
-  const status = buildInstallStatus(paths, detected);
+  const paths = resolveInstallPaths(root);
+  const detected = detectInstalledArtifacts(paths, root);
+  const status = buildInstallStatus(paths, detected, root);
 
   if (opts.json) {
-    const json: Record<string, string> = {};
-    if (status.binary) json.binary = status.binary;
+    const preview = resolveInstallTargetPreview(root, paths);
+    const json: Record<string, unknown> = {
+      agentIntegration: preview.agentIntegration,
+      effective: {
+        all: preview.all,
+        mcp: preview.mcp,
+        skill: preview.skill,
+      },
+    };
+    if (status.app) json.app = status.app;
     if (status.bashCompletion) json.bashCompletion = status.bashCompletion;
     if (status.zshCompletion) json.zshCompletion = status.zshCompletion;
     if (status.fishCompletion) json.fishCompletion = status.fishCompletion;
@@ -46,7 +59,7 @@ export function printInstallStatus(root: CliProgram, opts: InstallOpts): void {
 
   installOut(`Installed artifacts for ${root.key}:`, opts);
   const lines: [string, string | undefined][] = [
-    ["binary", status.binary],
+    ["app", status.app],
     ["bash completion", status.bashCompletion],
     ["zsh completion", status.zshCompletion],
     ["fish completion", status.fishCompletion],

package/src/install/target-base.ts

@@ -0,0 +1,93 @@
+import type { CliProgram, InstallAgentIntegration } from "../types.ts";
+import type { InstallPaths } from "./paths.ts";
+import type {
+  CliInstallArtifactKey,
+  DetectedSnapshot,
+  InstallAction,
+  InstallActionKind,
+  InstalledArtifacts,
+  InstallStatus,
+  InstallTargetCategory,
+  TargetPlanContext,
+  UninstallAction,
+} from "./target-types.ts";
+
+/** Shared lifecycle for one install artifact. */
+export abstract class InstallTarget {
+  abstract readonly key: CliInstallArtifactKey;
+  abstract readonly actionKind: InstallActionKind;
+  abstract readonly category: InstallTargetCategory;
+
+  /** Paired MCP/skill key for agentIntegration dedupe. */
+  readonly pairedKey?: CliInstallArtifactKey;
+
+  defaultIncludedInAll(integration: InstallAgentIntegration): boolean {
+    if (this.category === "core") return true;
+    if (this.category === "mcp") {
+      return integration === "mcp" || integration === "both";
+    }
+    return integration === "skill" || integration === "both";
+  }
+
+  abstract isAvailable(root: CliProgram, paths: InstallPaths): boolean;
+
+  /** Whether this artifact is installed (for scoped uninstall / refresh). */
+  abstract isDetected(paths: InstallPaths, root: CliProgram): boolean;
+
+  /** Writes detection flags into the shared snapshot. */
+  applyDetected(_paths: InstallPaths, _root: CliProgram, _out: InstalledArtifacts): void {
+    // default: subclasses override
+  }
+
+  /** Maps artifact key to detected boolean for plan scoping. */
+  detectedForSnapshot(detected: DetectedSnapshot): boolean {
+    return this.isDetectedFromSnapshot(detected);
+  }
+
+  protected abstract isDetectedFromSnapshot(detected: DetectedSnapshot): boolean;
+
+  statusLine(
+    paths: InstallPaths,
+    root: CliProgram,
+    detected: InstalledArtifacts,
+  ): string | undefined {
+    if (!this.isDetectedFromInstalled(detected)) return undefined;
+    return this.formatStatusLine(paths, root);
+  }
+
+  protected isDetectedFromInstalled(detected: InstalledArtifacts): boolean {
+    return this.isDetectedFromSnapshot(detected as DetectedSnapshot);
+  }
+
+  protected abstract formatStatusLine(paths: InstallPaths, root: CliProgram): string;
+
+  planInstall(ctx: TargetPlanContext): InstallAction[] {
+    if (!ctx.include(this.key)) return [];
+    return this.buildInstallActions(ctx);
+  }
+
+  planUninstall(ctx: TargetPlanContext): UninstallAction[] {
+    if (!ctx.include(this.key)) return [];
+    if (!this.isDetectedFromSnapshot(ctx.detected)) return [];
+    return this.buildUninstallActions(ctx);
+  }
+
+  preflight?(ctx: TargetPlanContext): string | null;
+
+  protected abstract buildInstallActions(ctx: TargetPlanContext): InstallAction[];
+
+  protected abstract buildUninstallActions(ctx: TargetPlanContext): UninstallAction[];
+
+  contributeStatus(
+    paths: InstallPaths,
+    root: CliProgram,
+    detected: InstalledArtifacts,
+    status: InstallStatus,
+  ): void {
+    const line = this.statusLine(paths, root, detected);
+    if (!line) return;
+    this.assignStatusLine(status, line);
+  }
+
+  protected abstract assignStatusLine(status: InstallStatus, line: string): void;
+}

package/src/install/target-detect.ts

@@ -0,0 +1,20 @@
+import type { CliProgram } from "../types.ts";
+import type { InstallPaths } from "./paths.ts";
+import { INSTALL_TARGETS } from "./target-registry.ts";
+import type { InstalledArtifacts, InstallStatus } from "./target-types.ts";
+
+export { buildDetectedSnapshot, detectInstalledArtifacts } from "./target-scope.ts";
+export type { InstalledArtifacts, InstallStatus } from "./target-types.ts";
+
+/** Builds a status inventory from detected artifacts. */
+export function buildInstallStatus(
+  paths: InstallPaths,
+  detected: InstalledArtifacts,
+  root: CliProgram,
+): InstallStatus {
+  const status: InstallStatus = {};
+  for (const target of INSTALL_TARGETS) {
+    target.contributeStatus(paths, root, detected, status);
+  }
+  return status;
+}