skillmux 0.1.1 → 0.1.3

package/dist/chunk-UMN3UJFN.js

@@ -0,0 +1,836 @@
+import {
+  InvalidIdentifierError,
+  UserConfigValidationError,
+  assertSkillSourceLayout,
+  buildConfigPath,
+  collectDoctorIssues,
+  copySkillContentsToManagedStore,
+  dedupeAndSortIssues,
+  discoverAgents,
+  loadUserConfig,
+  normalizeId,
+  printJson,
+  printTable,
+  readManifest,
+  resolveSkillmuxHome,
+  runAdopt,
+  runDisable,
+  runEnable,
+  runRemove,
+  runScan,
+  scanAgentSkills,
+  supportedPlatforms,
+  writeManifest
+} from "./chunk-DBEVDI27.js";
+
+// src/index.ts
+import { Command } from "commander";
+
+// src/commands/agents.ts
+import { homedir } from "os";
+function buildTableOutput(agents) {
+  return printTable(
+    agents.map((agent) => ({
+      id: agent.id,
+      name: agent.stableName,
+      path: agent.absoluteSkillsDirectoryPath,
+      exists: String(agent.exists),
+      supported: String(agent.supportedOnPlatform),
+      discovery: agent.discovery
+    })),
+    [
+      { key: "id", label: "Agent" },
+      { key: "name", label: "Name" },
+      { key: "path", label: "Path" },
+      { key: "exists", label: "Exists" },
+      { key: "supported", label: "Supported" },
+      { key: "discovery", label: "Discovery" }
+    ]
+  );
+}
+async function runAgents(options = {}) {
+  const homeDir = options.homeDir ?? homedir();
+  const resolvedPaths = resolveSkillmuxHome(homeDir);
+  const skillmuxHome = options.skillmuxHome ?? resolvedPaths.skillmuxHome;
+  const agents = await discoverAgents({
+    homeDir,
+    skillmuxHome,
+    platform: options.platform
+  });
+  return {
+    agents,
+    output: options.json === true ? printJson(agents) : buildTableOutput(agents)
+  };
+}
+
+// src/commands/config-add-agent.ts
+import { homedir as homedir2 } from "os";
+
+// src/config/agent-override-validation.ts
+import { isAbsolute } from "path";
+function normalizeRelativePath(value, field) {
+  const trimmed = value.trim();
+  if (trimmed.length === 0) {
+    throw new UserConfigValidationError(`${field} must not be empty`);
+  }
+  if (isAbsolute(trimmed)) {
+    throw new UserConfigValidationError(`${field} must be a relative path`);
+  }
+  const normalized = trimmed.replaceAll("\\", "/");
+  if (normalized === "." || normalized === ".." || normalized.startsWith("../") || normalized.includes("/../")) {
+    throw new UserConfigValidationError(`${field} must stay within the configured home-relative tree`);
+  }
+  return normalized.replace(/^\.\/+/, "");
+}
+function normalizeAgentId(value) {
+  const trimmed = value.trim();
+  if (trimmed.length === 0 || /[a-z0-9]/i.test(trimmed) === false) {
+    throw new InvalidIdentifierError("agent id", value);
+  }
+  return normalizeId(trimmed);
+}
+function normalizePlatforms(value) {
+  if (value === void 0 || value.length === 0) {
+    return [process.platform];
+  }
+  const normalized = [...new Set(value.map((entry) => entry.trim().toLowerCase()))];
+  const invalid = normalized.filter(
+    (entry) => supportedPlatforms.includes(entry) === false
+  );
+  if (invalid.length > 0) {
+    throw new UserConfigValidationError(
+      `platform must be one of: ${supportedPlatforms.join(", ")}`
+    );
+  }
+  return normalized;
+}
+
+// src/config/write-user-config.ts
+import * as fs from "fs/promises";
+async function writeUserConfig(skillmuxHome, config) {
+  const configPath = buildConfigPath(skillmuxHome);
+  await fs.mkdir(skillmuxHome, { recursive: true });
+  await fs.writeFile(configPath, `${JSON.stringify(config, null, 2)}
+`, "utf8");
+  return {
+    skillmuxHome,
+    configPath
+  };
+}
+
+// src/commands/config-add-agent.ts
+function buildAgentOverride(options) {
+  const agentId = normalizeAgentId(options.id);
+  const agent = {
+    supportedPlatforms: normalizePlatforms(options.platforms),
+    homeRelativeRootPath: normalizeRelativePath(options.root, "root"),
+    skillsDirectoryPath: normalizeRelativePath(options.skills ?? "skills", "skills")
+  };
+  if (options.name !== void 0 && options.name.trim().length > 0) {
+    agent.stableName = options.name.trim();
+  }
+  if (options.disabledByDefault === true) {
+    agent.enabledByDefault = false;
+  }
+  return { agentId, agent };
+}
+function buildTableOutput2(result) {
+  const summary = printTable(
+    [
+      {
+        agentId: result.agentId,
+        configPath: result.configPath,
+        changed: String(result.changed)
+      }
+    ],
+    [
+      { key: "agentId", label: "Agent" },
+      { key: "configPath", label: "Config Path" },
+      { key: "changed", label: "Changed" }
+    ]
+  );
+  const detail = printTable(
+    [
+      {
+        stableName: result.agent.stableName ?? "",
+        platforms: (result.agent.supportedPlatforms ?? []).join(","),
+        root: result.agent.homeRelativeRootPath ?? "",
+        skills: result.agent.skillsDirectoryPath ?? "",
+        enabledByDefault: result.agent.enabledByDefault === void 0 ? "" : String(result.agent.enabledByDefault)
+      }
+    ],
+    [
+      { key: "stableName", label: "Name" },
+      { key: "platforms", label: "Platforms" },
+      { key: "root", label: "Root" },
+      { key: "skills", label: "Skills Dir" },
+      { key: "enabledByDefault", label: "Enabled By Default" }
+    ]
+  );
+  return `${summary}${detail}`;
+}
+async function runConfigAddAgent(options) {
+  const homeDir = options.homeDir ?? homedir2();
+  const resolvedPaths = resolveSkillmuxHome(homeDir);
+  const skillmuxHome = options.skillmuxHome ?? resolvedPaths.skillmuxHome;
+  const configPath = buildConfigPath(skillmuxHome);
+  const config = await loadUserConfig(skillmuxHome);
+  const { agentId, agent } = buildAgentOverride(options);
+  const previous = config.agents[agentId];
+  const changed = JSON.stringify(previous ?? null) !== JSON.stringify(agent);
+  const nextConfig = {
+    ...config,
+    agents: {
+      ...config.agents,
+      [agentId]: agent
+    }
+  };
+  await writeUserConfig(skillmuxHome, nextConfig);
+  const resultWithoutOutput = {
+    skillmuxHome,
+    configPath,
+    agentId,
+    changed,
+    agent,
+    config: nextConfig
+  };
+  return {
+    ...resultWithoutOutput,
+    output: options.json === true ? printJson(resultWithoutOutput) : buildTableOutput2(resultWithoutOutput)
+  };
+}
+
+// src/commands/config-remove-agent.ts
+import { homedir as homedir3 } from "os";
+function normalizeAgentId2(value) {
+  const trimmed = value.trim();
+  if (trimmed.length === 0 || /[a-z0-9]/i.test(trimmed) === false) {
+    throw new InvalidIdentifierError("agent id", value);
+  }
+  return normalizeId(trimmed);
+}
+function buildTableOutput3(result) {
+  return printTable(
+    [
+      {
+        agentId: result.agentId,
+        configPath: result.configPath,
+        changed: String(result.changed),
+        removed: String(result.removed)
+      }
+    ],
+    [
+      { key: "agentId", label: "Agent" },
+      { key: "configPath", label: "Config Path" },
+      { key: "changed", label: "Changed" },
+      { key: "removed", label: "Removed" }
+    ]
+  );
+}
+async function runConfigRemoveAgent(options) {
+  const homeDir = options.homeDir ?? homedir3();
+  const resolvedPaths = resolveSkillmuxHome(homeDir);
+  const skillmuxHome = options.skillmuxHome ?? resolvedPaths.skillmuxHome;
+  const configPath = buildConfigPath(skillmuxHome);
+  const config = await loadUserConfig(skillmuxHome);
+  const agentId = normalizeAgentId2(options.id);
+  const removed = agentId in config.agents;
+  const nextConfig = {
+    ...config,
+    agents: Object.fromEntries(
+      Object.entries(config.agents).filter(([currentAgentId]) => currentAgentId !== agentId)
+    )
+  };
+  if (removed) {
+    await writeUserConfig(skillmuxHome, nextConfig);
+  }
+  const resultWithoutOutput = {
+    skillmuxHome,
+    configPath,
+    agentId,
+    changed: removed,
+    removed,
+    config: nextConfig
+  };
+  return {
+    ...resultWithoutOutput,
+    output: options.json === true ? printJson(resultWithoutOutput) : buildTableOutput3(resultWithoutOutput)
+  };
+}
+
+// src/commands/config-update-agent.ts
+import { homedir as homedir4 } from "os";
+function buildAgentPatch(options) {
+  const patch = {};
+  if (options.root !== void 0) {
+    patch.homeRelativeRootPath = normalizeRelativePath(options.root, "root");
+  }
+  if (options.skills !== void 0) {
+    patch.skillsDirectoryPath = normalizeRelativePath(options.skills, "skills");
+  }
+  if (options.name !== void 0 && options.name.trim().length > 0) {
+    patch.stableName = options.name.trim();
+  }
+  if (options.platforms !== void 0) {
+    patch.supportedPlatforms = normalizePlatforms(options.platforms);
+  }
+  if (options.enabledByDefault !== void 0 && options.disabledByDefault === true) {
+    throw new UserConfigValidationError(
+      "enabled-by-default and disabled-by-default cannot both be set"
+    );
+  }
+  if (options.enabledByDefault !== void 0) {
+    patch.enabledByDefault = options.enabledByDefault;
+  }
+  if (options.disabledByDefault === true) {
+    patch.enabledByDefault = false;
+  }
+  return patch;
+}
+function buildTableOutput4(result) {
+  const summary = printTable(
+    [
+      {
+        agentId: result.agentId,
+        configPath: result.configPath,
+        changed: String(result.changed)
+      }
+    ],
+    [
+      { key: "agentId", label: "Agent" },
+      { key: "configPath", label: "Config Path" },
+      { key: "changed", label: "Changed" }
+    ]
+  );
+  const detail = printTable(
+    [
+      {
+        stableName: result.agent.stableName ?? "",
+        platforms: (result.agent.supportedPlatforms ?? []).join(","),
+        root: result.agent.homeRelativeRootPath ?? "",
+        skills: result.agent.skillsDirectoryPath ?? "",
+        enabledByDefault: result.agent.enabledByDefault === void 0 ? "" : String(result.agent.enabledByDefault)
+      }
+    ],
+    [
+      { key: "stableName", label: "Name" },
+      { key: "platforms", label: "Platforms" },
+      { key: "root", label: "Root" },
+      { key: "skills", label: "Skills Dir" },
+      { key: "enabledByDefault", label: "Enabled By Default" }
+    ]
+  );
+  return `${summary}${detail}`;
+}
+async function runConfigUpdateAgent(options) {
+  const homeDir = options.homeDir ?? homedir4();
+  const resolvedPaths = resolveSkillmuxHome(homeDir);
+  const skillmuxHome = options.skillmuxHome ?? resolvedPaths.skillmuxHome;
+  const configPath = buildConfigPath(skillmuxHome);
+  const config = await loadUserConfig(skillmuxHome);
+  const agentId = normalizeAgentId(options.id);
+  const previous = config.agents[agentId];
+  if (previous === void 0) {
+    throw new UserConfigValidationError(`Agent override does not exist: ${agentId}`);
+  }
+  const agent = {
+    ...previous,
+    ...buildAgentPatch(options)
+  };
+  const changed = JSON.stringify(previous) !== JSON.stringify(agent);
+  const nextConfig = {
+    ...config,
+    agents: {
+      ...config.agents,
+      [agentId]: agent
+    }
+  };
+  if (changed) {
+    await writeUserConfig(skillmuxHome, nextConfig);
+  }
+  const resultWithoutOutput = {
+    skillmuxHome,
+    configPath,
+    agentId,
+    changed,
+    agent,
+    config: nextConfig
+  };
+  return {
+    ...resultWithoutOutput,
+    output: options.json === true ? printJson(resultWithoutOutput) : buildTableOutput4(resultWithoutOutput)
+  };
+}
+
+// src/commands/config.ts
+import { homedir as homedir5 } from "os";
+function buildTableOutput5(result) {
+  const summary = printTable(
+    [
+      {
+        skillmuxHome: result.skillmuxHome,
+        configPath: result.configPath,
+        overrides: String(Object.keys(result.config.agents).length)
+      }
+    ],
+    [
+      { key: "skillmuxHome", label: "SkillMux Home" },
+      { key: "configPath", label: "Config Path" },
+      { key: "overrides", label: "Overrides" }
+    ]
+  );
+  const agentRows = Object.entries(result.config.agents).sort(([left], [right]) => left.localeCompare(right)).map(([agentId, agent]) => ({
+    agentId,
+    stableName: agent.stableName ?? "",
+    root: agent.homeRelativeRootPath ?? "",
+    skills: agent.skillsDirectoryPath ?? ""
+  }));
+  if (agentRows.length === 0) {
+    return `${summary}
+No user overrides configured.
+`;
+  }
+  return `${summary}
+${printTable(agentRows, [
+    { key: "agentId", label: "Agent" },
+    { key: "stableName", label: "Name" },
+    { key: "root", label: "Root" },
+    { key: "skills", label: "Skills Dir" }
+  ])}`;
+}
+async function runConfig(options = {}) {
+  const homeDir = options.homeDir ?? homedir5();
+  const resolvedPaths = resolveSkillmuxHome(homeDir);
+  const skillmuxHome = options.skillmuxHome ?? resolvedPaths.skillmuxHome;
+  const config = await loadUserConfig(skillmuxHome);
+  const resultWithoutOutput = {
+    skillmuxHome,
+    configPath: buildConfigPath(skillmuxHome),
+    config
+  };
+  return {
+    ...resultWithoutOutput,
+    output: options.json === true ? printJson(resultWithoutOutput) : buildTableOutput5(resultWithoutOutput)
+  };
+}
+
+// src/commands/doctor.ts
+import { homedir as homedir6 } from "os";
+function buildTableOutput6(issues) {
+  if (issues.length === 0) {
+    return "No doctor issues found.\n";
+  }
+  return printTable(
+    issues.map((issue) => ({
+      severity: issue.severity,
+      code: issue.code,
+      path: issue.path ?? "",
+      message: issue.message
+    })),
+    [
+      { key: "severity", label: "Severity" },
+      { key: "code", label: "Code" },
+      { key: "path", label: "Path" },
+      { key: "message", label: "Message" }
+    ]
+  );
+}
+function buildJsonOutput(result) {
+  return printJson({
+    skillmuxHome: result.skillmuxHome,
+    issues: result.issues,
+    agents: result.agents.map((agent) => ({
+      id: agent.id,
+      path: agent.absoluteSkillsDirectoryPath,
+      supportedOnPlatform: agent.supportedOnPlatform
+    })),
+    entries: result.entries
+  });
+}
+async function runDoctor(options = {}) {
+  const homeDir = options.homeDir ?? homedir6();
+  const resolvedPaths = resolveSkillmuxHome(homeDir);
+  const skillmuxHome = options.skillmuxHome ?? resolvedPaths.skillmuxHome;
+  const [manifest, config, agents] = await Promise.all([
+    readManifest(skillmuxHome),
+    loadUserConfig(skillmuxHome),
+    discoverAgents({
+      homeDir,
+      skillmuxHome,
+      platform: options.platform
+    })
+  ]);
+  const entries = [];
+  const issues = [];
+  for (const agent of agents) {
+    const scannedAgent = await scanAgentSkills(agent, skillmuxHome);
+    entries.push(...scannedAgent.entries);
+    issues.push(...scannedAgent.issues);
+  }
+  const doctorIssues = await collectDoctorIssues({
+    manifest,
+    agents,
+    entries
+  });
+  const dedupedIssues = dedupeAndSortIssues([...issues, ...doctorIssues]);
+  const resultWithoutOutput = {
+    skillmuxHome,
+    manifest,
+    config,
+    agents,
+    entries,
+    issues: dedupedIssues
+  };
+  return {
+    ...resultWithoutOutput,
+    output: options.json === true ? buildJsonOutput(resultWithoutOutput) : buildTableOutput6(dedupedIssues)
+  };
+}
+
+// src/commands/import.ts
+import { resolve } from "path";
+import { homedir as homedir7 } from "os";
+function buildManagedSkillPath(skillmuxHome, skillId) {
+  return resolve(skillmuxHome, "skills", skillId);
+}
+async function runImport(options) {
+  const homeDir = options.homeDir ?? homedir7();
+  const resolvedPaths = resolveSkillmuxHome(homeDir);
+  const skillmuxHome = options.skillmuxHome ?? resolvedPaths.skillmuxHome;
+  const sourcePath = resolve(options.sourcePath);
+  const skillId = normalizeId(options.skillName);
+  const importedAt = (options.now ?? /* @__PURE__ */ new Date()).toISOString();
+  const manifest = await readManifest(skillmuxHome);
+  const managedSkillPath = buildManagedSkillPath(skillmuxHome, skillId);
+  await assertSkillSourceLayout(sourcePath);
+  if (manifest.skills[skillId] !== void 0) {
+    throw new Error(`Managed skill already exists for ${skillId}`);
+  }
+  await copySkillContentsToManagedStore(sourcePath, managedSkillPath);
+  const skill = {
+    id: skillId,
+    name: options.skillName,
+    path: managedSkillPath,
+    source: {
+      kind: "local",
+      path: sourcePath
+    },
+    importedAt
+  };
+  manifest.skills[skillId] = skill;
+  await writeManifest(skillmuxHome, manifest);
+  return {
+    skill,
+    manifest,
+    output: `Imported ${skillId} to ${managedSkillPath}
+`
+  };
+}
+
+// src/commands/list.ts
+function buildRecordsView(scanResult) {
+  return {
+    view: "records",
+    records: scanResult.entries,
+    issues: scanResult.issues
+  };
+}
+function buildAgentsView(scanResult) {
+  const groups = /* @__PURE__ */ new Map();
+  for (const agent of scanResult.agents) {
+    groups.set(agent.id, {
+      agentId: agent.id,
+      agentName: agent.stableName,
+      entries: []
+    });
+  }
+  for (const entry of scanResult.entries) {
+    const current = groups.get(entry.agentId) ?? {
+      agentId: entry.agentId,
+      agentName: entry.agentName,
+      entries: []
+    };
+    current.entries.push(entry);
+    groups.set(entry.agentId, current);
+  }
+  return {
+    view: "agents",
+    agents: [...groups.values()].sort(
+      (left, right) => left.agentId.localeCompare(right.agentId)
+    ),
+    issues: scanResult.issues
+  };
+}
+function buildSkillsView(scanResult) {
+  const groups = /* @__PURE__ */ new Map();
+  for (const skill of Object.values(scanResult.manifest.skills)) {
+    groups.set(skill.id, {
+      skillName: skill.id,
+      entries: []
+    });
+  }
+  for (const entry of scanResult.entries) {
+    const current = groups.get(entry.skillName) ?? {
+      skillName: entry.skillName,
+      entries: []
+    };
+    current.entries.push(entry);
+    groups.set(entry.skillName, current);
+  }
+  return {
+    view: "skills",
+    skills: [...groups.values()].sort(
+      (left, right) => left.skillName.localeCompare(right.skillName)
+    ),
+    issues: scanResult.issues
+  };
+}
+function buildListData(scanResult, view) {
+  if (view === "agents") {
+    return buildAgentsView(scanResult);
+  }
+  if (view === "skills") {
+    return buildSkillsView(scanResult);
+  }
+  return buildRecordsView(scanResult);
+}
+function buildTableOutput7(data, view) {
+  if (view === "agents") {
+    const agentRows = data.agents;
+    return printTable(
+      agentRows.map((agent) => ({
+        agent: agent.agentId,
+        name: agent.agentName,
+        entries: String(agent.entries.length)
+      })),
+      [
+        { key: "agent", label: "Agent" },
+        { key: "name", label: "Name" },
+        { key: "entries", label: "Entries" }
+      ]
+    );
+  }
+  if (view === "skills") {
+    const skillRows = data.skills;
+    return printTable(
+      skillRows.map((skill) => ({
+        skill: skill.skillName,
+        entries: String(skill.entries.length)
+      })),
+      [
+        { key: "skill", label: "Skill" },
+        { key: "entries", label: "Entries" }
+      ]
+    );
+  }
+  const records = data.records;
+  return printTable(
+    records.map((record) => ({
+      agent: record.agentId,
+      skill: record.skillName,
+      kind: record.kind
+    })),
+    [
+      { key: "agent", label: "Agent" },
+      { key: "skill", label: "Skill" },
+      { key: "kind", label: "Kind" }
+    ]
+  );
+}
+async function runList(options = {}) {
+  const view = options.view ?? "records";
+  const format = options.format ?? "table";
+  const scanResult = await runScan(options);
+  const data = buildListData(scanResult, view);
+  return {
+    data,
+    output: format === "json" ? printJson(data) : buildTableOutput7(data, view)
+  };
+}
+
+// src/tui/tty.ts
+function isInteractiveTerminal(stdin, stdout) {
+  return stdin.isTTY === true && stdout.isTTY === true;
+}
+
+// src/commands/tui.ts
+var TuiNonInteractiveTerminalError = class extends Error {
+  constructor() {
+    super("skillmux tui requires an interactive terminal");
+    this.name = "TuiNonInteractiveTerminalError";
+  }
+};
+async function launchDefaultTui(options) {
+  const { launchTui } = await import("./launch-tui-PHWJPIQZ.js");
+  await launchTui(options);
+}
+async function runTui(options = {}) {
+  const stdin = options.stdin ?? process.stdin;
+  const stdout = options.stdout ?? process.stdout;
+  const stderr = options.stderr ?? process.stderr;
+  if (!isInteractiveTerminal(stdin, stdout)) {
+    stderr.write(
+      "skillmux tui requires an interactive terminal. Use skillmux list, skillmux scan, or skillmux doctor for non-interactive output.\n"
+    );
+    throw new TuiNonInteractiveTerminalError();
+  }
+  await (options.launch ?? launchDefaultTui)({
+    homeDir: options.homeDir,
+    skillmuxHome: options.skillmuxHome
+  });
+}
+
+// src/index.ts
+function collectValues(value, previous = []) {
+  return [...previous, value];
+}
+function requireSingleValue(values, label) {
+  if (values.length !== 1) {
+    throw new Error(`Expected exactly one ${label}`);
+  }
+  return values[0];
+}
+function requireAtLeastOneValue(values, label) {
+  if (values.length === 0) {
+    throw new Error(`Expected at least one ${label}`);
+  }
+  return values;
+}
+function buildCli() {
+  const program = new Command();
+  program.name("skillmux");
+  program.command("adopt").requiredOption("--agent <agent>", "Source agent id").option("--skill <skill>", "Repeatable installed skill to adopt", collectValues, []).option("--json", "Emit structured JSON output").action(async (options) => {
+    const result = options.skill.length === 0 ? await runAdopt({
+      agent: options.agent,
+      json: options.json === true
+    }) : options.skill.length === 1 ? await runAdopt({
+      agent: options.agent,
+      skill: options.skill[0],
+      json: options.json === true
+    }) : await runAdopt({
+      agent: options.agent,
+      skills: options.skill,
+      json: options.json === true
+    });
+    process.stdout.write(result.output);
+  });
+  program.command("scan").option("--json", "Emit structured JSON output").action(async (options) => {
+    const result = await runScan({ json: options.json === true });
+    process.stdout.write(result.output);
+  });
+  program.command("agents").option("--json", "Emit structured JSON output").action(async (options) => {
+    const result = await runAgents({ json: options.json === true });
+    process.stdout.write(result.output);
+  });
+  program.command("list").option("--view <view>", "Select records, agents, or skills view", "records").option("--format <format>", "Select table or json output", "table").action(async (options) => {
+    const result = await runList({
+      view: options.view,
+      format: options.format
+    });
+    process.stdout.write(result.output);
+  });
+  program.command("import").requiredOption("--source <path>", "Local skill source directory").requiredOption("--name <name>", "Managed skill name").action(async (options) => {
+    const result = await runImport({
+      sourcePath: options.source,
+      skillName: options.name
+    });
+    process.stdout.write(result.output);
+  });
+  program.command("doctor").option("--json", "Emit structured JSON output").action(async (options) => {
+    const result = await runDoctor({ json: options.json === true });
+    process.stdout.write(result.output);
+  });
+  program.command("tui").description("Open the interactive SkillMux dashboard").action(async () => {
+    try {
+      await runTui();
+    } catch (error) {
+      if (error instanceof TuiNonInteractiveTerminalError) {
+        process.exitCode = 1;
+        return;
+      }
+      throw error;
+    }
+  });
+  const configCommand = program.command("config");
+  configCommand.option("--json", "Emit structured JSON output").action(async (options) => {
+    const result = await runConfig({ json: options.json === true });
+    process.stdout.write(result.output);
+  });
+  configCommand.command("add-agent").requiredOption("--id <id>", "Agent id").requiredOption("--root <path>", "Home-relative root path").option("--skills <path>", "Skills directory path relative to the agent root", "skills").option("--name <name>", "Stable display name").option(
+    "--platform <platform>",
+    `Supported platform (${supportedPlatforms.join(", ")})`,
+    (value, previous = []) => [...previous, value],
+    []
+  ).option("--disabled-by-default", "Mark this custom agent as disabled by default").option("--json", "Emit structured JSON output").action(
+    async (options) => {
+      const result = await runConfigAddAgent({
+        id: options.id,
+        root: options.root,
+        skills: options.skills,
+        name: options.name,
+        platforms: options.platform,
+        disabledByDefault: options.disabledByDefault === true,
+        json: options.json === true
+      });
+      process.stdout.write(result.output);
+    }
+  );
+  configCommand.command("remove-agent").requiredOption("--id <id>", "Agent id").option("--json", "Emit structured JSON output").action(async (options) => {
+    const result = await runConfigRemoveAgent({
+      id: options.id,
+      json: options.json === true
+    });
+    process.stdout.write(result.output);
+  });
+  configCommand.command("update-agent").requiredOption("--id <id>", "Agent id").option("--root <path>", "Home-relative root path").option("--skills <path>", "Skills directory path relative to the agent root").option("--name <name>", "Stable display name").option(
+    "--platform <platform>",
+    `Supported platform (${supportedPlatforms.join(", ")})`,
+    (value, previous = []) => [...previous, value],
+    []
+  ).option("--enabled-by-default", "Mark this custom agent as enabled by default").option("--disabled-by-default", "Mark this custom agent as disabled by default").option("--json", "Emit structured JSON output").action(
+    async (options) => {
+      const result = await runConfigUpdateAgent({
+        id: options.id,
+        root: options.root,
+        skills: options.skills,
+        name: options.name,
+        platforms: options.platform !== void 0 && options.platform.length > 0 ? options.platform : void 0,
+        enabledByDefault: options.enabledByDefault === true ? true : void 0,
+        disabledByDefault: options.disabledByDefault === true,
+        json: options.json === true
+      });
+      process.stdout.write(result.output);
+    }
+  );
+  program.command("enable").requiredOption("--skill <skill>", "Managed skill name or id", collectValues, []).requiredOption("--agent <agent>", "Repeatable target agent", collectValues, []).action(async (options) => {
+    const result = await runEnable({
+      skill: requireSingleValue(options.skill, "skill"),
+      agents: requireAtLeastOneValue(options.agent, "agent")
+    });
+    process.stdout.write(result.output);
+  });
+  program.command("disable").requiredOption("--skill <skill>", "Managed skill name or id", collectValues, []).requiredOption("--agent <agent>", "Repeatable target agent", collectValues, []).action(async (options) => {
+    const result = await runDisable({
+      skill: requireSingleValue(options.skill, "skill"),
+      agents: requireAtLeastOneValue(options.agent, "agent")
+    });
+    process.stdout.write(result.output);
+  });
+  program.command("remove").requiredOption("--skill <skill>", "Repeatable managed skill name or id", collectValues, []).option("--json", "Emit structured JSON output").action(async (options) => {
+    const skills = requireAtLeastOneValue(options.skill, "skill");
+    const result = skills.length === 1 ? await runRemove({
+      skill: skills[0],
+      json: options.json === true
+    }) : await runRemove({
+      skills,
+      json: options.json === true
+    });
+    process.stdout.write(result.output);
+  });
+  return program;
+}
+
+export {
+  buildCli
+};
+//# sourceMappingURL=chunk-UMN3UJFN.js.map