argsbarg 4.1.1 → 5.0.2

package/src/config/file.test.ts

@@ -1,3 +1,7 @@
+/*
+Tests for config/file module behavior.
+*/
+
 import { describe, expect, test } from "bun:test";
 import { existsSync, mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
 import { tmpdir } from "node:os";
@@ -40,7 +44,9 @@ function withHome<T>(fn: (home: string) => T): T {
   }
 }
 
+/** Tests for config/file. */
 describe("config/file", () => {
+  /** BuildProgramUserConfig from program.appConfig env entries. */
   test("buildProgramUserConfig from program.appConfig env entries", () => {
     const cfg = buildProgramUserConfig(program);
     expect(cfg?.api_token).toMatchObject({
@@ -51,6 +57,7 @@ describe("config/file", () => {
     expect(cfg?.port).toBeUndefined();
   });
 
+  /** ResolveAppConfigPath uses config.json. */
   test("resolveAppConfigPath uses config.json", () => {
     withHome((home) => {
       expect(resolveAppConfigPath(program)).toBe(
@@ -59,6 +66,7 @@ describe("config/file", () => {
     });
   });
 
+  /** ResolveAppConfig prefers host env over file. */
   test("resolveAppConfig prefers host env over file", () => {
     withHome((_home) => {
       const prevToken = process.env.API_TOKEN;
@@ -76,6 +84,7 @@ describe("config/file", () => {
     });
   });
 
+  /** MissingRequiredConfig and formatMissingConfigMessage. */
   test("missingRequiredConfig and formatMissingConfigMessage", () => {
     const prev = process.env.API_TOKEN;
     delete process.env.API_TOKEN;
@@ -85,12 +94,13 @@ describe("config/file", () => {
       expect(missing).toContain("apiToken");
       expect(missing).not.toContain("port");
       const msg = formatMissingConfigMessage(program, missing);
-      expect(msg).toContain("install --configure");
+      expect(msg).toContain("configure");
     } finally {
       if (prev !== undefined) process.env.API_TOKEN = prev;
     }
   });
 
+  /** Rejects unknown keys on read. */
   test("rejects unknown keys on read", () => {
     withHome(() => {
       const configPath = resolveAppConfigPath(program);
@@ -100,6 +110,7 @@ describe("config/file", () => {
     });
   });
 
+  /** WriteAppConfigFile round-trip. */
   test("writeAppConfigFile round-trip", () => {
     withHome(() => {
       writeAppConfigFile(program, { apiToken: "saved" });
@@ -108,6 +119,7 @@ describe("config/file", () => {
     });
   });
 
+  /** Tests that uninstallAppConfig removes config directory recursively. */
   test("uninstallAppConfig removes config directory recursively", () => {
     withHome(() => {
       writeAppConfigFile(program, { apiToken: "saved" });

package/src/config/resolve.test.ts

@@ -1,3 +1,7 @@
+/*
+Tests for config/resolve module behavior.
+*/
+
 import { describe, expect, test } from "bun:test";
 import type { CliProgram } from "../types.ts";
 import { captureMappedHostEnv, exportConfigToEnv, resolveAppConfig } from "./resolve.ts";
@@ -25,7 +29,9 @@ const program: CliProgram = {
   handler: () => {},
 };
 
+/** Tests for config/resolve. */
 describe("config/resolve", () => {
+  /** Tests that prefers env over file for mapped keys. */
   test("prefers env over file for mapped keys", () => {
     const prev = process.env.API_TOKEN;
     process.env.API_TOKEN = "from-env";
@@ -38,6 +44,7 @@ describe("config/resolve", () => {
     }
   });
 
+  /** Tests that uses file when env empty. */
   test("uses file when env empty", () => {
     const prev = process.env.API_TOKEN;
     delete process.env.API_TOKEN;
@@ -49,6 +56,7 @@ describe("config/resolve", () => {
     }
   });
 
+  /** Tests that empty string in env or file counts as missing. */
   test("empty string in env or file counts as missing", () => {
     const prev = process.env.API_TOKEN;
     process.env.API_TOKEN = "";
@@ -61,6 +69,7 @@ describe("config/resolve", () => {
     }
   });
 
+  /** Applies jsonSchema default when file and env absent. */
   test("applies jsonSchema default when file and env absent", () => {
     const prev = process.env.API_TOKEN;
     delete process.env.API_TOKEN;
@@ -73,6 +82,7 @@ describe("config/resolve", () => {
     }
   });
 
+  /** All-string mode uses entry.default. */
   test("all-string mode uses entry.default", () => {
     const stringProgram: CliProgram = {
       ...program,
@@ -86,6 +96,7 @@ describe("config/resolve", () => {
     expect(resolved.greeting).toBe("world");
   });
 
+  /** Tests that prefers captured host env over file when process.env was exported from file. */
   test("prefers captured host env over file when process.env was exported from file", () => {
     const hostEnv = { API_TOKEN: "from-host" };
     process.env.API_TOKEN = "from-file-export";
@@ -97,6 +108,7 @@ describe("config/resolve", () => {
     }
   });
 
+  /** ExportConfigToEnv does not overwrite host env. */
   test("exportConfigToEnv does not overwrite host env", () => {
     const prev = process.env.API_TOKEN;
     process.env.API_TOKEN = "from-host";
@@ -110,6 +122,7 @@ describe("config/resolve", () => {
     }
   });
 
+  /** Resolve callback supplies value when env and file are absent. */
   test("resolve callback supplies value when env and file are absent", () => {
     const resolveProgram: CliProgram = {
       ...program,
@@ -135,6 +148,7 @@ describe("config/resolve", () => {
     }
   });
 
+  /** Env overrides resolve callback. */
   test("env overrides resolve callback", () => {
     const resolveProgram: CliProgram = {
       ...program,
@@ -161,6 +175,7 @@ describe("config/resolve", () => {
     }
   });
 
+  /** File overrides resolve callback. */
   test("file overrides resolve callback", () => {
     const resolveProgram: CliProgram = {
       ...program,
@@ -186,6 +201,7 @@ describe("config/resolve", () => {
     }
   });
 
+  /** Tests that falls back to env when resolve returns undefined. */
   test("falls back to env when resolve returns undefined", () => {
     const resolveProgram: CliProgram = {
       ...program,
@@ -212,6 +228,7 @@ describe("config/resolve", () => {
     }
   });
 
+  /** Resolve callback is skipped when env is set. */
   test("resolve callback is skipped when env is set", () => {
     let resolveCalled = false;
     const resolveProgram: CliProgram = {
@@ -243,6 +260,7 @@ describe("config/resolve", () => {
     }
   });
 
+  /** Tests that async resolve is ignored with stderr warning. */
   test("async resolve is ignored with stderr warning", () => {
     const resolveProgram: CliProgram = {
       ...program,

package/src/config/resolve.ts

@@ -226,7 +226,7 @@ export function formatMissingConfigMessage(program: CliProgram, keys: string[]):
   const path = displayAppConfigPath(program);
   return [
     `Missing required configuration: ${list}`,
-    `Configure interactively:  ${program.key} install --configure`,
+    `Configure interactively:  ${program.key} configure`,
     `Or set via:               ${program.key} config set <key> <value>`,
     `Config file:              ${path}`,
     `See:                      ${program.key} docs mcp`,
@@ -239,7 +239,7 @@ export function formatMcpMissingConfigMessage(program: CliProgram, keys: string[
   const path = displayAppConfigPath(program);
   return [
     `Missing required configuration: ${list}`,
-    `Configure: ${program.key} install --configure`,
+    `Configure: ${program.key} configure`,
     `Or set via: ${program.key} config set`,
     `Config file: ${path}`,
   ].join("\n");

package/src/config/validate.test.ts

@@ -1,3 +1,7 @@
+/*
+Tests for config/validate module behavior.
+*/
+
 import { describe, expect, test } from "bun:test";
 import { parseConfigSetValue, validateConfigDocument } from "./validate.ts";
 
@@ -17,7 +21,9 @@ const rootSchema = {
   },
 };
 
+/** Tests for config/validate. */
 describe("config/validate", () => {
+  /** Tests that accepts valid document. */
   test("accepts valid document", () => {
     const result = validateConfigDocument(
       { apiToken: "x", maxRetries: 3, prefs: { ttl: 3600 } },
@@ -27,12 +33,14 @@ describe("config/validate", () => {
     expect(result.errors).toEqual([]);
   });
 
+  /** Rejects missing required property. */
   test("rejects missing required property", () => {
     const result = validateConfigDocument({ apiToken: "x" }, rootSchema);
     expect(result.valid).toBe(false);
     expect(result.errors.some((e) => e.includes("maxRetries"))).toBe(true);
   });
 
+  /** Rejects unknown property when additionalProperties is false. */
   test("rejects unknown property when additionalProperties is false", () => {
     const result = validateConfigDocument(
       { apiToken: "x", maxRetries: 1, extra: true },
@@ -42,16 +50,19 @@ describe("config/validate", () => {
     expect(result.errors.some((e) => e.includes("extra"))).toBe(true);
   });
 
+  /** Rejects type mismatch. */
   test("rejects type mismatch", () => {
     const result = validateConfigDocument({ apiToken: "x", maxRetries: "nope" }, rootSchema);
     expect(result.valid).toBe(false);
   });
 
+  /** ParseConfigSetValue coerces number and boolean. */
   test("parseConfigSetValue coerces number and boolean", () => {
     expect(parseConfigSetValue("5", { type: "integer" }, rootSchema, false)).toBe(5);
     expect(parseConfigSetValue("true", { type: "boolean" }, rootSchema, false)).toBe(true);
   });
 
+  /** ParseConfigSetValue requires --json for objects. */
   test("parseConfigSetValue requires --json for objects", () => {
     expect(() => parseConfigSetValue('{"ttl":1}', { type: "object" }, rootSchema, false)).toThrow(
       /--json/,

package/src/config.integration.test.ts

@@ -10,6 +10,7 @@ import { bootstrapAppConfig } from "./config/bootstrap.ts";
 import { resolveAppConfigPath } from "./config/file.ts";
 import { mcpRequest, testProgram } from "./test-fixtures.ts";
 
+/** Tests that bootstrapAppConfig prefers host env over config file. */
 test("bootstrapAppConfig prefers host env over config file", () => {
   const dir = mkdtempSync(join(tmpdir(), "argsbarg-env-"));
   const prevHome = process.env.HOME;
@@ -43,6 +44,7 @@ test("bootstrapAppConfig prefers host env over config file", () => {
   }
 });
 
+/** MCP program.appConfig fails when required config missing. */
 test("MCP program.appConfig fails when required config missing", async () => {
   const responses = await mcpRequest(
     [
@@ -60,6 +62,7 @@ test("MCP program.appConfig fails when required config missing", async () => {
   expect(res.result.content[0]?.text).toContain("argsTestSecret");
 });
 
+/** MCP program.appConfig succeeds when env present. */
 test("MCP program.appConfig succeeds when env present", async () => {
   const responses = await mcpRequest(
     [
@@ -77,6 +80,7 @@ test("MCP program.appConfig succeeds when env present", async () => {
   expect(res.result.content[0]?.text.trim()).toBe("sekrit");
 });
 
+/** MCP config file loads and exports vars for tool handlers. */
 test("MCP config file loads and exports vars for tool handlers", async () => {
   const dir = mkdtempSync(join(tmpdir(), "argsbarg-mcp-"));
   const configFile = join(dir, ".local", "lib", "mcp_test", "config");
@@ -106,6 +110,7 @@ test("MCP config file loads and exports vars for tool handlers", async () => {
   rmSync(dir, { recursive: true, force: true });
 });
 
+/** Cli.run docs api skips required appConfig exit. */
 test("Cli.run docs api skips required appConfig exit", async () => {
   const dir = mkdtempSync(join(tmpdir(), "argsbarg-docs-skip-"));
   const configFile = join(dir, ".local", "lib", "docs_skip_test", "config");

package/src/configure/configure.test.ts

@@ -0,0 +1,170 @@
+/*
+Tests for configure/configure module behavior.
+*/
+
+import { afterEach, beforeEach, 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 {
+  appConfigHasEntries,
+  parseConfigureOpts,
+  validateConfigureOpts,
+} from "../configure/index.ts";
+import { detectInstalledArtifacts } from "../install/detect-installed.ts";
+import { parseInstallOpts } from "../install/opts.ts";
+import { resolveClaudeDesktopMcpPath, resolveInstallPaths } from "../install/paths.ts";
+import { buildInstallPlan, buildUpdatePlan } from "../install/plan.ts";
+import { buildUninstallPlan } from "../install/uninstall.ts";
+import type { CliProgram } from "../types.ts";
+
+const fixture: CliProgram = {
+  key: "testapp",
+  version: "0.0.0",
+  description: "Test",
+  mcpServer: { enabled: true },
+  handler: () => {},
+};
+
+let home: string;
+let prevHome: string | undefined;
+let prevXdg: string | undefined;
+
+beforeEach(() => {
+  home = mkdtempSync(join(tmpdir(), "argsbarg-configure-"));
+  prevHome = process.env.HOME;
+  prevXdg = process.env.XDG_CONFIG_HOME;
+  process.env.HOME = home;
+  delete process.env.XDG_CONFIG_HOME;
+});
+
+afterEach(() => {
+  if (prevHome === undefined) delete process.env.HOME;
+  else process.env.HOME = prevHome;
+  if (prevXdg === undefined) delete process.env.XDG_CONFIG_HOME;
+  else process.env.XDG_CONFIG_HOME = prevXdg;
+  rmSync(home, { recursive: true, force: true });
+});
+
+/** Tests for configure opts. */
+describe("configure opts", () => {
+  /** Validate rejects multiple modes. */
+  test("validate rejects multiple modes", () => {
+    const opts = parseConfigureOpts({ sync: "1", status: "1" });
+    expect(validateConfigureOpts(opts)).toContain("only one");
+  });
+
+  /** Sync requires --yes. */
+  test("sync requires --yes", () => {
+    const opts = parseConfigureOpts({ sync: "1" });
+    expect(validateConfigureOpts(opts)).toContain("--yes");
+  });
+
+  /** Remove-all requires --yes. */
+  test("remove-all requires --yes", () => {
+    const opts = parseConfigureOpts({ "remove-all": "1" });
+    expect(validateConfigureOpts(opts)).toContain("--yes");
+  });
+});
+
+/** Tests for install paths. */
+describe("install paths", () => {
+  /** ResolveInstallPaths includes skill and mcp paths. */
+  test("resolveInstallPaths includes skill and mcp paths", () => {
+    const paths = resolveInstallPaths(fixture);
+    expect(paths.cursorSkillDir).toContain(".cursor/skills");
+    expect(paths.cursorMcpPath).toContain("mcp.json");
+  });
+
+  /** Claude desktop mcp path on darwin. */
+  test("claude desktop mcp path on darwin", () => {
+    const prev = process.platform;
+    Object.defineProperty(process, "platform", { value: "darwin" });
+    try {
+      expect(resolveClaudeDesktopMcpPath(home)).toBe(
+        join(home, "Library", "Application Support", "Claude", "claude_desktop_config.json"),
+      );
+    } finally {
+      Object.defineProperty(process, "platform", { value: prev });
+    }
+  });
+});
+
+/** Tests for detect installed. */
+describe("detect installed", () => {
+  /** Detects cursor mcp when configured. */
+  test("detects cursor mcp when configured", () => {
+    const paths = resolveInstallPaths(fixture);
+    mkdirSync(join(home, ".cursor"), { recursive: true });
+    writeFileSync(
+      paths.cursorMcpPath,
+      JSON.stringify({ mcpServers: { testapp: { command: "testapp", args: ["mcp"] } } }),
+      "utf8",
+    );
+
+    const detected = detectInstalledArtifacts(paths, fixture);
+    expect(detected.cursorMcp).toBe(true);
+    expect(detected.app).toBe(false);
+  });
+});
+
+/** Tests for sync plan. */
+describe("sync plan", () => {
+  /** BuildUpdatePlan greenfield includes agent targets. */
+  test("buildUpdatePlan greenfield includes agent targets", () => {
+    const paths = resolveInstallPaths(fixture);
+    const plan = buildUpdatePlan(fixture, paths, parseInstallOpts({ reinstall: "1", yes: "1" }));
+    expect(plan.length).toBeGreaterThan(0);
+    expect(plan.some((a) => a.kind === "app")).toBe(false);
+  });
+
+  /** BuildInstallPlan --all omits app self-install. */
+  test("buildInstallPlan --all omits app self-install", () => {
+    const paths = resolveInstallPaths(fixture);
+    const plan = buildInstallPlan(fixture, paths, parseInstallOpts({ all: "1" }));
+    expect(plan.some((a) => a.kind === "app")).toBe(false);
+    expect(plan.some((a) => a.kind.endsWith("-mcp"))).toBe(true);
+  });
+
+  /** BuildInstallPlan respects configure.agentIntegration skill. */
+  test("buildInstallPlan respects configure.agentIntegration skill", () => {
+    const skillApp: CliProgram = {
+      ...fixture,
+      configure: { agentIntegration: "skill" },
+    };
+    const paths = resolveInstallPaths(skillApp);
+    mkdirSync(join(home, ".claude"), { recursive: true });
+    mkdirSync(join(home, ".cursor"), { recursive: true });
+    const plan = buildInstallPlan(skillApp, paths, parseInstallOpts({ mcp: "1" }));
+    expect(plan.some((a) => a.kind.endsWith("-mcp"))).toBe(false);
+  });
+});
+
+/** Tests for remove plan. */
+describe("remove plan", () => {
+  /** BuildUninstallPlan --all with nothing installed is empty. */
+  test("buildUninstallPlan --all with nothing installed is empty", () => {
+    const paths = resolveInstallPaths(fixture);
+    const plan = buildUninstallPlan(fixture, paths, parseInstallOpts({ uninstall: "1", all: "1" }));
+    expect(plan.length).toBe(0);
+  });
+});
+
+/** Tests for app config wizard. */
+describe("app config wizard", () => {
+  /** Tests that appConfigHasEntries when entries exist. */
+  test("appConfigHasEntries when entries exist", () => {
+    expect(
+      appConfigHasEntries({
+        ...fixture,
+        appConfig: { entries: { token: { description: "API token." } } },
+      }),
+    ).toBe(true);
+  });
+
+  /** Tests that appConfigHasEntries false for empty entries or missing appConfig. */
+  test("appConfigHasEntries false for empty entries or missing appConfig", () => {
+    expect(appConfigHasEntries({ ...fixture, appConfig: { entries: {} } })).toBe(false);
+    expect(appConfigHasEntries(fixture)).toBe(false);
+  });
+});