skillmux 0.1.0

package/dist/index.js

@@ -0,0 +1,1535 @@
+// src/index.ts
+import { Command } from "commander";
+
+// src/commands/agents.ts
+import { homedir } from "os";
+
+// src/config/resolve-skillmux-home.ts
+import { join, resolve } from "path";
+function buildConfigPath(skillmuxHome) {
+  return join(resolve(skillmuxHome), "config.json");
+}
+function resolveSkillmuxHome(homeDir) {
+  const resolvedHomeDir = resolve(homeDir);
+  const skillmuxHome = join(resolvedHomeDir, ".skillmux");
+  return {
+    skillmuxHome,
+    configPath: buildConfigPath(skillmuxHome)
+  };
+}
+
+// src/discovery/discover-agents.ts
+import * as fs2 from "fs/promises";
+import { join as join2, resolve as resolve2 } from "path";
+
+// src/config/default-agent-rules.ts
+var supportedPlatforms = ["win32", "linux", "darwin"];
+var builtInAgentIds = [
+  "codex",
+  "claude",
+  "gemini",
+  "agents",
+  "openclaw"
+];
+var defaultAgentRules = [
+  {
+    id: "codex",
+    stableName: "OpenAI Codex",
+    supportedPlatforms: [...supportedPlatforms],
+    homeRelativeRootPath: ".codex",
+    skillsDirectoryPath: "skills",
+    enabledByDefault: true,
+    discovery: "builtin"
+  },
+  {
+    id: "claude",
+    stableName: "Claude Code",
+    supportedPlatforms: [...supportedPlatforms],
+    homeRelativeRootPath: ".claude",
+    skillsDirectoryPath: "skills",
+    enabledByDefault: true,
+    discovery: "builtin"
+  },
+  {
+    id: "gemini",
+    stableName: "Gemini CLI",
+    supportedPlatforms: [...supportedPlatforms],
+    homeRelativeRootPath: ".gemini",
+    skillsDirectoryPath: "skills",
+    enabledByDefault: true,
+    discovery: "builtin"
+  },
+  {
+    id: "agents",
+    stableName: "Agents",
+    supportedPlatforms: [...supportedPlatforms],
+    homeRelativeRootPath: ".agents",
+    skillsDirectoryPath: "skills",
+    enabledByDefault: true,
+    discovery: "builtin"
+  },
+  {
+    id: "openclaw",
+    stableName: "OpenClaw",
+    supportedPlatforms: [...supportedPlatforms],
+    homeRelativeRootPath: ".openclaw",
+    skillsDirectoryPath: "skills",
+    enabledByDefault: true,
+    discovery: "builtin"
+  }
+];
+var defaultAgentRuleMap = Object.fromEntries(
+  defaultAgentRules.map((rule) => [rule.id, rule])
+);
+
+// src/config/load-user-config.ts
+import * as fs from "fs/promises";
+import { z } from "zod";
+
+// src/core/errors.ts
+var SkillMuxError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = new.target.name;
+  }
+};
+var ManifestValidationError = class extends SkillMuxError {
+  constructor(message) {
+    super(message);
+  }
+};
+var UserConfigValidationError = class extends SkillMuxError {
+  constructor(message) {
+    super(message);
+  }
+};
+
+// src/config/load-user-config.ts
+var supportedPlatformSchema = z.enum(supportedPlatforms);
+var agentOverrideSchema = z.object({
+  stableName: z.string().min(1).optional(),
+  supportedPlatforms: z.array(supportedPlatformSchema).min(1).optional(),
+  homeRelativeRootPath: z.string().min(1).optional(),
+  skillsDirectoryPath: z.string().min(1).optional(),
+  enabledByDefault: z.boolean().optional()
+}).strict();
+var userConfigSchema = z.object({
+  version: z.literal(1),
+  agents: z.record(z.string().min(1), agentOverrideSchema)
+}).strict();
+function createEmptyUserConfig() {
+  return {
+    version: 1,
+    agents: {}
+  };
+}
+function formatValidationIssues(error) {
+  return error.issues.map((issue) => {
+    const path = issue.path.length > 0 ? issue.path.join(".") : "<root>";
+    return `${path}: ${issue.message}`;
+  }).join("; ");
+}
+async function loadUserConfig(skillmuxHome) {
+  const configPath = buildConfigPath(skillmuxHome);
+  try {
+    const contents = await fs.readFile(configPath, "utf8");
+    const parsed = JSON.parse(contents);
+    const validated = userConfigSchema.safeParse(parsed);
+    if (!validated.success) {
+      throw new UserConfigValidationError(
+        `Invalid config at ${configPath}: ${formatValidationIssues(validated.error)}`
+      );
+    }
+    return validated.data;
+  } catch (error) {
+    if (typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT") {
+      return createEmptyUserConfig();
+    }
+    if (error instanceof SyntaxError) {
+      throw new UserConfigValidationError(
+        `Invalid config at ${configPath}: malformed JSON`
+      );
+    }
+    throw error;
+  }
+}
+
+// src/discovery/discover-agents.ts
+function mergeRule(rule, override) {
+  if (override === void 0) {
+    return rule;
+  }
+  return {
+    ...rule,
+    ...override
+  };
+}
+function buildCustomRule(id, override) {
+  if (override.homeRelativeRootPath === void 0 || override.skillsDirectoryPath === void 0) {
+    throw new Error(
+      `Custom agent override "${id}" must define homeRelativeRootPath and skillsDirectoryPath`
+    );
+  }
+  return {
+    id,
+    stableName: override.stableName ?? id,
+    supportedPlatforms: override.supportedPlatforms ?? [...supportedPlatforms],
+    homeRelativeRootPath: override.homeRelativeRootPath,
+    skillsDirectoryPath: override.skillsDirectoryPath,
+    enabledByDefault: override.enabledByDefault ?? true,
+    discovery: "custom"
+  };
+}
+async function pathExists(path) {
+  try {
+    await fs2.access(path);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function resolveAgentRulePaths(homeDir, rule) {
+  const absoluteRootPath = resolve2(homeDir, rule.homeRelativeRootPath);
+  return {
+    absoluteRootPath,
+    absoluteSkillsDirectoryPath: join2(
+      absoluteRootPath,
+      rule.skillsDirectoryPath
+    )
+  };
+}
+async function discoverAgents(options) {
+  const platform = options.platform ?? process.platform;
+  const homeDir = resolve2(options.homeDir);
+  const skillmuxHome = options.skillmuxHome ?? resolveSkillmuxHome(homeDir).skillmuxHome;
+  const userConfig = await loadUserConfig(skillmuxHome);
+  const discoveredAgents = [];
+  for (const agentId of builtInAgentIds) {
+    const mergedRule = mergeRule(
+      defaultAgentRuleMap[agentId],
+      userConfig.agents[agentId]
+    );
+    const resolvedPaths = resolveAgentRulePaths(homeDir, mergedRule);
+    discoveredAgents.push({
+      ...mergedRule,
+      ...resolvedPaths,
+      exists: await pathExists(resolvedPaths.absoluteSkillsDirectoryPath),
+      supportedOnPlatform: mergedRule.supportedPlatforms.some(
+        (supportedPlatform) => supportedPlatform === platform
+      )
+    });
+  }
+  for (const [agentId, override] of Object.entries(userConfig.agents)) {
+    if (Object.hasOwn(defaultAgentRuleMap, agentId)) {
+      continue;
+    }
+    const customRule = buildCustomRule(agentId, override);
+    const resolvedPaths = resolveAgentRulePaths(homeDir, customRule);
+    discoveredAgents.push({
+      ...customRule,
+      ...resolvedPaths,
+      exists: await pathExists(resolvedPaths.absoluteSkillsDirectoryPath),
+      supportedOnPlatform: customRule.supportedPlatforms.some(
+        (supportedPlatform) => supportedPlatform === platform
+      )
+    });
+  }
+  return discoveredAgents;
+}
+
+// src/output/print-json.ts
+function printJson(value) {
+  return `${JSON.stringify(value, null, 2)}
+`;
+}
+
+// src/output/print-table.ts
+function printTable(rows, columns) {
+  const renderedRows = rows.map(
+    (row) => columns.map((column) => String(row[column.key] ?? ""))
+  );
+  const widths = columns.map(
+    (column, index) => Math.max(
+      column.label.length,
+      ...renderedRows.map((row) => row[index]?.length ?? 0)
+    )
+  );
+  const header = columns.map((column, index) => column.label.padEnd(widths[index])).join("  ");
+  const separator = widths.map((width) => "-".repeat(width)).join("  ");
+  const body = renderedRows.map(
+    (row) => row.map((cell, index) => cell.padEnd(widths[index])).join("  ")
+  );
+  return `${[header, separator, ...body].join("\n")}
+`;
+}
+
+// src/commands/agents.ts
+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.ts
+import { homedir as homedir2 } from "os";
+function buildTableOutput2(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 ?? homedir2();
+  const resolvedPaths = resolveSkillmuxHome(homeDir);
+  const skillmuxHome = options.skillmuxHome ?? resolvedPaths.skillmuxHome;
+  const config = await loadUserConfig(skillmuxHome);
+  const resultWithoutOutput = {
+    skillmuxHome,
+    configPath: resolvedPaths.configPath,
+    config
+  };
+  return {
+    ...resultWithoutOutput,
+    output: options.json === true ? printJson(resultWithoutOutput) : buildTableOutput2(resultWithoutOutput)
+  };
+}
+
+// src/commands/doctor.ts
+import * as fs8 from "fs/promises";
+import { homedir as homedir3 } from "os";
+import { join as join5 } from "path";
+
+// src/discovery/scan-agent-skills.ts
+import * as fs5 from "fs/promises";
+
+// src/discovery/infer-skill-entry.ts
+import * as fs4 from "fs/promises";
+import { basename, resolve as resolve4 } from "path";
+
+// src/fs/path-utils.ts
+import * as fs3 from "fs/promises";
+import { dirname, parse, relative, resolve as resolve3, sep } from "path";
+function normalizeAbsolutePath(path) {
+  const normalized = resolve3(path);
+  return process.platform === "win32" ? normalized.replaceAll("/", "\\").toLowerCase() : normalized;
+}
+function pathsAreEqual(left, right) {
+  return normalizeAbsolutePath(left) === normalizeAbsolutePath(right);
+}
+function isPathInside(parentPath, childPath) {
+  const parent = normalizeAbsolutePath(parentPath);
+  const child = normalizeAbsolutePath(childPath);
+  if (parse(parent).root !== parse(child).root) {
+    return false;
+  }
+  const relativePath = relative(parent, child);
+  if (relativePath === "") {
+    return true;
+  }
+  if (relativePath === "..") {
+    return false;
+  }
+  if (relativePath.startsWith(`..${sep}`)) {
+    return false;
+  }
+  return true;
+}
+async function assertNoSymlinkAncestors(path, options) {
+  let current = options?.includeLeaf === true ? resolve3(path) : dirname(resolve3(path));
+  while (true) {
+    try {
+      const entry = await fs3.lstat(current);
+      if (entry.isSymbolicLink()) {
+        throw new Error(`Refusing to use path with symlink ancestor at ${current}`);
+      }
+    } catch (error) {
+      if (error.code !== "ENOENT") {
+        throw error;
+      }
+    }
+    const parent = dirname(current);
+    if (parent === current) {
+      return;
+    }
+    current = parent;
+  }
+}
+
+// src/discovery/infer-skill-entry.ts
+function buildIssue(code, severity, message, path) {
+  return { code, severity, message, path };
+}
+async function inferSkillEntry(options) {
+  const absolutePath = resolve4(options.path);
+  const skillName = basename(absolutePath);
+  const stats = await fs4.lstat(absolutePath);
+  if (stats.isSymbolicLink()) {
+    try {
+      const targetPath = await fs4.realpath(absolutePath);
+      if (isPathInside(options.skillmuxHome, targetPath)) {
+        return {
+          entry: {
+            agentId: options.agentId,
+            agentName: options.agentName,
+            skillName,
+            kind: "managed-link",
+            path: absolutePath,
+            targetPath
+          }
+        };
+      }
+      return {
+        entry: {
+          agentId: options.agentId,
+          agentName: options.agentName,
+          skillName,
+          kind: "unknown",
+          path: absolutePath,
+          targetPath
+        },
+        issue: buildIssue(
+          "unknown-entry",
+          "warning",
+          "Skill entry is a link that points outside the SkillMux managed store",
+          absolutePath
+        )
+      };
+    } catch (error) {
+      if (error.code !== "ENOENT") {
+        throw error;
+      }
+      return {
+        entry: {
+          agentId: options.agentId,
+          agentName: options.agentName,
+          skillName,
+          kind: "broken-link",
+          path: absolutePath
+        },
+        issue: buildIssue(
+          "broken-link",
+          "error",
+          "Skill entry points to a missing target",
+          absolutePath
+        )
+      };
+    }
+  }
+  if (stats.isDirectory()) {
+    return {
+      entry: {
+        agentId: options.agentId,
+        agentName: options.agentName,
+        skillName,
+        kind: "unmanaged-directory",
+        path: absolutePath
+      }
+    };
+  }
+  return {
+    entry: {
+      agentId: options.agentId,
+      agentName: options.agentName,
+      skillName,
+      kind: "unknown",
+      path: absolutePath
+    },
+    issue: buildIssue(
+      "unknown-entry",
+      "warning",
+      "Skill entry is neither a managed link nor a directory",
+      absolutePath
+    )
+  };
+}
+
+// src/discovery/scan-agent-skills.ts
+async function scanAgentSkills(agent, skillmuxHome) {
+  if (!agent.exists || !agent.supportedOnPlatform) {
+    return {
+      entries: [],
+      issues: []
+    };
+  }
+  const directoryEntries = await fs5.readdir(agent.absoluteSkillsDirectoryPath, {
+    withFileTypes: true
+  });
+  const sortedDirectoryEntries = [...directoryEntries].sort(
+    (left, right) => left.name.localeCompare(right.name)
+  );
+  const entries = [];
+  const issues = [];
+  for (const directoryEntry of sortedDirectoryEntries) {
+    const result = await inferSkillEntry({
+      agentId: agent.id,
+      agentName: agent.stableName,
+      path: `${agent.absoluteSkillsDirectoryPath}/${directoryEntry.name}`,
+      skillmuxHome
+    });
+    entries.push(result.entry);
+    if (result.issue !== void 0) {
+      issues.push(result.issue);
+    }
+  }
+  return {
+    entries,
+    issues
+  };
+}
+
+// src/manifest/read-manifest.ts
+import * as fs7 from "fs/promises";
+import { join as join4, resolve as resolve5 } from "path";
+
+// src/manifest/build-empty-manifest.ts
+function buildEmptyManifest(skillmuxHome) {
+  return {
+    version: 1,
+    skillmuxHome,
+    skills: {},
+    agents: {},
+    activations: [],
+    lastScan: {
+      at: null,
+      issues: []
+    }
+  };
+}
+
+// src/manifest/manifest-schema.ts
+import { z as z2 } from "zod";
+
+// src/core/ids.ts
+var ID_PATTERN = /^[a-z0-9]+(?:-[a-z0-9]+)*$/;
+function normalizeId(value) {
+  const normalized = value.trim().toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
+  return normalized.length > 0 ? normalized : "skill";
+}
+function isValidId(value) {
+  return ID_PATTERN.test(value);
+}
+
+// src/manifest/manifest-schema.ts
+var idSchema = z2.string().min(1).refine(isValidId, "Expected a canonical lowercase slug identifier");
+var scanIssueSchema = z2.object({
+  code: z2.string().min(1),
+  severity: z2.enum(["info", "warning", "error"]),
+  message: z2.string().min(1),
+  path: z2.string().min(1).optional()
+}).strict();
+var managedSkillSchema = z2.object({
+  id: idSchema,
+  name: z2.string().min(1),
+  path: z2.string().min(1),
+  source: z2.object({
+    kind: z2.enum(["local", "imported"]),
+    path: z2.string().min(1)
+  }).strict(),
+  importedAt: z2.string().min(1)
+}).strict();
+var agentRecordSchema = z2.object({
+  id: idSchema,
+  name: z2.string().min(1),
+  path: z2.string().min(1),
+  discovery: z2.enum(["builtin", "custom"]),
+  available: z2.boolean(),
+  lastSeenAt: z2.string().min(1).nullable()
+}).strict();
+var activationRecordSchema = z2.object({
+  skillId: idSchema,
+  agentId: idSchema,
+  linkPath: z2.string().min(1),
+  state: z2.enum(["enabled", "disabled"]),
+  updatedAt: z2.string().min(1)
+}).strict();
+var manifestSchema = z2.object({
+  version: z2.literal(1),
+  skillmuxHome: z2.string().min(1),
+  skills: z2.record(z2.string(), managedSkillSchema),
+  agents: z2.record(z2.string(), agentRecordSchema),
+  activations: z2.array(activationRecordSchema),
+  lastScan: z2.object({
+    at: z2.string().min(1).nullable(),
+    issues: z2.array(scanIssueSchema)
+  }).strict()
+}).strict().superRefine((manifest, ctx) => {
+  for (const [skillId, skill] of Object.entries(manifest.skills)) {
+    if (!isValidId(skillId)) {
+      ctx.addIssue({
+        code: z2.ZodIssueCode.custom,
+        path: ["skills", skillId],
+        message: `Invalid skill id key: ${skillId}`
+      });
+    }
+    if (skill.id !== skillId) {
+      ctx.addIssue({
+        code: z2.ZodIssueCode.custom,
+        path: ["skills", skillId, "id"],
+        message: `Skill id must match its record key: ${skillId}`
+      });
+    }
+  }
+  for (const [agentId, agent] of Object.entries(manifest.agents)) {
+    if (!isValidId(agentId)) {
+      ctx.addIssue({
+        code: z2.ZodIssueCode.custom,
+        path: ["agents", agentId],
+        message: `Invalid agent id key: ${agentId}`
+      });
+    }
+    if (agent.id !== agentId) {
+      ctx.addIssue({
+        code: z2.ZodIssueCode.custom,
+        path: ["agents", agentId, "id"],
+        message: `Agent id must match its record key: ${agentId}`
+      });
+    }
+  }
+  const activationPairs = /* @__PURE__ */ new Set();
+  manifest.activations.forEach((activation, index) => {
+    if (!(activation.skillId in manifest.skills)) {
+      ctx.addIssue({
+        code: z2.ZodIssueCode.custom,
+        path: ["activations", index, "skillId"],
+        message: `Unknown skill reference: ${activation.skillId}`
+      });
+    }
+    if (!(activation.agentId in manifest.agents)) {
+      ctx.addIssue({
+        code: z2.ZodIssueCode.custom,
+        path: ["activations", index, "agentId"],
+        message: `Unknown agent reference: ${activation.agentId}`
+      });
+    }
+    const pairKey = `${activation.skillId}:${activation.agentId}`;
+    if (activationPairs.has(pairKey)) {
+      ctx.addIssue({
+        code: z2.ZodIssueCode.custom,
+        path: ["activations", index],
+        message: `Duplicate activation for ${pairKey}`
+      });
+      return;
+    }
+    activationPairs.add(pairKey);
+  });
+});
+
+// src/manifest/write-manifest.ts
+import { randomUUID } from "crypto";
+import * as fs6 from "fs/promises";
+import { join as join3 } from "path";
+function getManifestPath(home) {
+  return join3(home, "manifest.json");
+}
+function createManifestTempPath(manifestPath) {
+  return `${manifestPath}.${process.pid}.${randomUUID()}.tmp`;
+}
+async function writeManifest(home, manifest) {
+  await fs6.mkdir(home, { recursive: true });
+  const manifestPath = getManifestPath(home);
+  const tempPath = createManifestTempPath(manifestPath);
+  const contents = `${JSON.stringify(manifest, null, 2)}
+`;
+  await fs6.writeFile(tempPath, contents, "utf8");
+  try {
+    await fs6.rename(tempPath, manifestPath);
+  } catch (error) {
+    await fs6.unlink(tempPath).catch(() => void 0);
+    throw error;
+  }
+}
+
+// src/manifest/read-manifest.ts
+function getManifestPath2(home) {
+  return join4(home, "manifest.json");
+}
+function normalizeHomePath(home) {
+  const resolvedHome = resolve5(home);
+  return process.platform === "win32" ? resolvedHome.toLowerCase() : resolvedHome;
+}
+function formatValidationIssues2(error) {
+  return error.issues.map((issue) => {
+    const path = issue.path.length > 0 ? issue.path.join(".") : "<root>";
+    return `${path}: ${issue.message}`;
+  }).join("; ");
+}
+async function readManifest(home) {
+  const manifestPath = getManifestPath2(home);
+  try {
+    const contents = await fs7.readFile(manifestPath, "utf8");
+    const parsedJson = JSON.parse(contents);
+    const parsedManifest = manifestSchema.safeParse(parsedJson);
+    if (!parsedManifest.success) {
+      throw new ManifestValidationError(
+        `Invalid manifest at ${manifestPath}: ${formatValidationIssues2(parsedManifest.error)}`
+      );
+    }
+    if (normalizeHomePath(parsedManifest.data.skillmuxHome) !== normalizeHomePath(home)) {
+      throw new ManifestValidationError(
+        `Invalid manifest at ${manifestPath}: skillmuxHome must match ${home}`
+      );
+    }
+    return parsedManifest.data;
+  } catch (error) {
+    if (typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT") {
+      const emptyManifest = buildEmptyManifest(home);
+      await writeManifest(home, emptyManifest);
+      return emptyManifest;
+    }
+    if (error instanceof SyntaxError) {
+      throw new ManifestValidationError(
+        `Invalid manifest at ${manifestPath}: malformed JSON`
+      );
+    }
+    throw error;
+  }
+}
+
+// src/commands/doctor.ts
+function buildIssue2(code, severity, message, path) {
+  return path === void 0 ? { code, severity, message } : { code, severity, message, path };
+}
+async function pathExists2(path) {
+  try {
+    await fs8.access(path);
+    return true;
+  } catch (error) {
+    if (error.code === "ENOENT") {
+      return false;
+    }
+    throw error;
+  }
+}
+async function addUnmanagedDirectoryIssues(entries, issues) {
+  for (const entry of entries) {
+    if (entry.kind !== "unmanaged-directory") {
+      continue;
+    }
+    if (await pathExists2(join5(entry.path, "SKILL.md"))) {
+      issues.push(
+        buildIssue2(
+          "unmanaged-skill-directory",
+          "warning",
+          `Unmanaged skill directory is present for ${entry.agentId}/${entry.skillName}`,
+          entry.path
+        )
+      );
+    }
+  }
+}
+async function addMissingManagedSkillIssues(manifest, issues) {
+  for (const skill of Object.values(manifest.skills)) {
+    if (await pathExists2(skill.path)) {
+      continue;
+    }
+    issues.push(
+      buildIssue2(
+        "missing-managed-skill-path",
+        "error",
+        `Managed skill path is missing for ${skill.id}`,
+        skill.path
+      )
+    );
+  }
+}
+function addConflictingAgentPathIssues(agents, issues) {
+  const pathToAgents = /* @__PURE__ */ new Map();
+  for (const agent of agents) {
+    const key = normalizeAbsolutePath(agent.absoluteSkillsDirectoryPath);
+    const current = pathToAgents.get(key) ?? [];
+    current.push(agent);
+    pathToAgents.set(key, current);
+  }
+  for (const conflictedAgents of pathToAgents.values()) {
+    if (conflictedAgents.length < 2) {
+      continue;
+    }
+    const agentIds = conflictedAgents.map((agent) => agent.id).sort((left, right) => left.localeCompare(right));
+    issues.push(
+      buildIssue2(
+        "conflicting-agent-path",
+        "warning",
+        `Multiple agents resolve to the same skills directory: ${agentIds.join(", ")}`,
+        conflictedAgents[0].absoluteSkillsDirectoryPath
+      )
+    );
+  }
+}
+function buildTableOutput3(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 ?? homedir3();
+  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);
+  }
+  await addUnmanagedDirectoryIssues(entries, issues);
+  await addMissingManagedSkillIssues(manifest, issues);
+  addConflictingAgentPathIssues(agents, issues);
+  const dedupedIssues = [...issues].sort((left, right) => {
+    const leftKey = `${left.severity}:${left.code}:${left.path ?? ""}:${left.message}`;
+    const rightKey = `${right.severity}:${right.code}:${right.path ?? ""}:${right.message}`;
+    return leftKey.localeCompare(rightKey);
+  });
+  const resultWithoutOutput = {
+    skillmuxHome,
+    manifest,
+    config,
+    agents,
+    entries,
+    issues: dedupedIssues
+  };
+  return {
+    ...resultWithoutOutput,
+    output: options.json === true ? buildJsonOutput(resultWithoutOutput) : buildTableOutput3(dedupedIssues)
+  };
+}
+
+// src/commands/disable.ts
+import * as fs11 from "fs/promises";
+import { homedir as homedir4 } from "os";
+import { join as join6 } from "path";
+
+// src/fs/link-ops.ts
+import * as fs9 from "fs/promises";
+import { dirname as dirname2, resolve as resolve6 } from "path";
+var directoryLinkType = process.platform === "win32" ? "junction" : "dir";
+async function createManagedLink(linkPath, targetPath) {
+  const resolvedLinkPath = resolve6(linkPath);
+  const resolvedTargetPath = resolve6(targetPath);
+  await assertNoSymlinkAncestors(resolvedLinkPath);
+  await assertNoSymlinkAncestors(resolvedTargetPath, { includeLeaf: true });
+  await fs9.mkdir(dirname2(resolvedLinkPath), { recursive: true });
+  try {
+    const existingEntry = await fs9.lstat(resolvedLinkPath);
+    if (!existingEntry.isSymbolicLink()) {
+      throw new Error(`Refusing to replace non-link entry at ${resolvedLinkPath}`);
+    }
+    const currentTargetPath = await fs9.realpath(resolvedLinkPath);
+    if (pathsAreEqual(currentTargetPath, resolvedTargetPath)) {
+      return;
+    }
+    throw new Error(`Refusing to replace link at ${resolvedLinkPath}`);
+  } catch (error) {
+    if (error.code === "ENOENT" && await fs9.lstat(resolvedLinkPath).then((entry) => entry.isSymbolicLink()).catch(() => false)) {
+      await fs9.rm(resolvedLinkPath, { recursive: true, force: false });
+    } else if (error.code !== "ENOENT") {
+      throw error;
+    }
+  }
+  await fs9.symlink(resolvedTargetPath, resolvedLinkPath, directoryLinkType);
+}
+async function isLinkPointingToTarget(linkPath, targetPath) {
+  try {
+    const entry = await fs9.lstat(linkPath);
+    if (!entry.isSymbolicLink()) {
+      return false;
+    }
+    const resolvedTargetPath = await fs9.realpath(linkPath);
+    return pathsAreEqual(resolvedTargetPath, targetPath);
+  } catch (error) {
+    if (error.code === "ENOENT") {
+      return false;
+    }
+    throw error;
+  }
+}
+
+// src/fs/safe-remove-link.ts
+import * as fs10 from "fs/promises";
+async function safeRemoveLink(path) {
+  try {
+    const entry = await fs10.lstat(path);
+    if (!entry.isSymbolicLink()) {
+      return false;
+    }
+    await fs10.rm(path, { recursive: true, force: false });
+    return true;
+  } catch (error) {
+    if (error.code === "ENOENT") {
+      return false;
+    }
+    throw error;
+  }
+}
+
+// src/commands/disable.ts
+function buildAgentRecord(agent, timestamp) {
+  return {
+    id: agent.id,
+    name: agent.stableName,
+    path: agent.absoluteSkillsDirectoryPath,
+    discovery: agent.discovery,
+    available: agent.exists && agent.supportedOnPlatform,
+    lastSeenAt: agent.exists ? timestamp : null
+  };
+}
+function buildActivationRecord(skillId, agentId, linkPath, timestamp) {
+  return {
+    skillId,
+    agentId,
+    linkPath,
+    state: "disabled",
+    updatedAt: timestamp
+  };
+}
+function upsertActivation(manifest, activation) {
+  const index = manifest.activations.findIndex(
+    (entry) => entry.skillId === activation.skillId && entry.agentId === activation.agentId
+  );
+  if (index === -1) {
+    manifest.activations.push(activation);
+    return;
+  }
+  manifest.activations[index] = activation;
+}
+async function resolveTargetAgent(homeDir, skillmuxHome, agentName) {
+  const agentId = normalizeId(agentName);
+  const agents = await discoverAgents({ homeDir, skillmuxHome });
+  const agent = agents.find((entry) => entry.id === agentId);
+  if (agent === void 0) {
+    throw new Error(`Unknown agent: ${agentName}`);
+  }
+  if (!agent.supportedOnPlatform) {
+    throw new Error(`Agent ${agent.id} is not supported on ${process.platform}`);
+  }
+  return agent;
+}
+async function pathExists3(path) {
+  try {
+    await fs11.lstat(path);
+    return true;
+  } catch (error) {
+    if (error.code === "ENOENT") {
+      return false;
+    }
+    throw error;
+  }
+}
+async function runDisable(options) {
+  const homeDir = options.homeDir ?? homedir4();
+  const { skillmuxHome: defaultSkillmuxHome } = resolveSkillmuxHome(homeDir);
+  const skillmuxHome = options.skillmuxHome ?? defaultSkillmuxHome;
+  const timestamp = (options.now ?? /* @__PURE__ */ new Date()).toISOString();
+  const manifest = await readManifest(skillmuxHome);
+  const skillId = normalizeId(options.skill);
+  const skill = manifest.skills[skillId];
+  if (skill === void 0) {
+    throw new Error(`Managed skill not found: ${skillId}`);
+  }
+  const agent = await resolveTargetAgent(homeDir, skillmuxHome, options.agent);
+  const currentActivation = manifest.activations.find(
+    (entry) => entry.skillId === skill.id && entry.agentId === agent.id
+  );
+  const linkPath = currentActivation?.linkPath ?? join6(agent.absoluteSkillsDirectoryPath, skill.id);
+  const agentRecord = buildAgentRecord(agent, timestamp);
+  manifest.agents[agent.id] = agentRecord;
+  const linkMatchesSkill = await isLinkPointingToTarget(linkPath, skill.path);
+  if (!linkMatchesSkill && await pathExists3(linkPath)) {
+    throw new Error(`Refusing to disable non-managed entry at ${linkPath}`);
+  }
+  const removedLink = linkMatchesSkill ? await safeRemoveLink(linkPath) : false;
+  if (removedLink === false && currentActivation?.state !== "enabled") {
+    return {
+      changed: false,
+      skill,
+      agent: agentRecord,
+      activation: currentActivation ?? null,
+      manifest,
+      output: `${skill.id} is already disabled for ${agent.id}
+`
+    };
+  }
+  const activation = buildActivationRecord(skill.id, agent.id, linkPath, timestamp);
+  upsertActivation(manifest, activation);
+  await writeManifest(skillmuxHome, manifest);
+  return {
+    changed: true,
+    skill,
+    agent: agentRecord,
+    activation,
+    manifest,
+    output: `Disabled ${skill.id} for ${agent.id}
+`
+  };
+}
+
+// src/commands/enable.ts
+import * as fs12 from "fs/promises";
+import { homedir as homedir5 } from "os";
+import { join as join7 } from "path";
+function buildAgentRecord2(agent, timestamp) {
+  return {
+    id: agent.id,
+    name: agent.stableName,
+    path: agent.absoluteSkillsDirectoryPath,
+    discovery: agent.discovery,
+    available: agent.supportedOnPlatform,
+    lastSeenAt: timestamp
+  };
+}
+function buildActivationRecord2(skillId, agentId, linkPath, timestamp, state) {
+  return {
+    skillId,
+    agentId,
+    linkPath,
+    state,
+    updatedAt: timestamp
+  };
+}
+function upsertActivation2(manifest, activation) {
+  const index = manifest.activations.findIndex(
+    (entry) => entry.skillId === activation.skillId && entry.agentId === activation.agentId
+  );
+  if (index === -1) {
+    manifest.activations.push(activation);
+    return;
+  }
+  manifest.activations[index] = activation;
+}
+async function resolveTargetAgent2(homeDir, skillmuxHome, agentName) {
+  const agentId = normalizeId(agentName);
+  const agents = await discoverAgents({ homeDir, skillmuxHome });
+  const agent = agents.find((entry) => entry.id === agentId);
+  if (agent === void 0) {
+    throw new Error(`Unknown agent: ${agentName}`);
+  }
+  if (!agent.supportedOnPlatform) {
+    throw new Error(`Agent ${agent.id} is not supported on ${process.platform}`);
+  }
+  return agent;
+}
+async function runEnable(options) {
+  const homeDir = options.homeDir ?? homedir5();
+  const { skillmuxHome: defaultSkillmuxHome } = resolveSkillmuxHome(homeDir);
+  const skillmuxHome = options.skillmuxHome ?? defaultSkillmuxHome;
+  const timestamp = (options.now ?? /* @__PURE__ */ new Date()).toISOString();
+  const manifest = await readManifest(skillmuxHome);
+  const skillId = normalizeId(options.skill);
+  const skill = manifest.skills[skillId];
+  if (skill === void 0) {
+    throw new Error(`Managed skill not found: ${skillId}`);
+  }
+  const agent = await resolveTargetAgent2(homeDir, skillmuxHome, options.agent);
+  const linkPath = join7(agent.absoluteSkillsDirectoryPath, skill.id);
+  const currentActivation = manifest.activations.find(
+    (entry) => entry.skillId === skill.id && entry.agentId === agent.id
+  );
+  const agentRecord = buildAgentRecord2(agent, timestamp);
+  manifest.agents[agent.id] = agentRecord;
+  await fs12.mkdir(agent.absoluteSkillsDirectoryPath, { recursive: true });
+  const linkAlreadyEnabled = await isLinkPointingToTarget(linkPath, skill.path);
+  const activationAlreadyEnabled = currentActivation?.state === "enabled" && currentActivation.linkPath === linkPath;
+  if (linkAlreadyEnabled && activationAlreadyEnabled) {
+    return {
+      changed: false,
+      skill,
+      agent: agentRecord,
+      activation: currentActivation,
+      manifest,
+      output: `${skill.id} is already enabled for ${agent.id}
+`
+    };
+  }
+  await createManagedLink(linkPath, skill.path);
+  const activation = buildActivationRecord2(
+    skill.id,
+    agent.id,
+    linkPath,
+    timestamp,
+    "enabled"
+  );
+  upsertActivation2(manifest, activation);
+  await writeManifest(skillmuxHome, manifest);
+  return {
+    changed: true,
+    skill,
+    agent: agentRecord,
+    activation,
+    manifest,
+    output: `Enabled ${skill.id} for ${agent.id}
+`
+  };
+}
+
+// src/commands/import.ts
+import { resolve as resolve8 } from "path";
+import { homedir as homedir6 } from "os";
+
+// src/fs/safe-copy.ts
+import * as fs13 from "fs/promises";
+import { dirname as dirname3, join as join8, resolve as resolve7 } from "path";
+async function assertDirectory(path) {
+  const entry = await fs13.lstat(path);
+  if (!entry.isDirectory()) {
+    throw new Error(`Expected a directory at ${path}`);
+  }
+}
+async function assertRegularFile(path, label) {
+  const entry = await fs13.lstat(path);
+  if (!entry.isFile()) {
+    throw new Error(`Expected ${label} to be a regular file at ${path}`);
+  }
+}
+async function assertTargetDoesNotExist(path) {
+  try {
+    await fs13.lstat(path);
+    throw new Error(`Refusing to overwrite existing path at ${path}`);
+  } catch (error) {
+    if (error.code !== "ENOENT") {
+      throw error;
+    }
+  }
+}
+async function copyDirectoryContents(sourcePath, targetPath) {
+  await fs13.mkdir(targetPath, { recursive: true });
+  const entries = await fs13.readdir(sourcePath, { withFileTypes: true });
+  for (const entry of entries) {
+    const sourceEntryPath = join8(sourcePath, entry.name);
+    const targetEntryPath = join8(targetPath, entry.name);
+    const entryStats = await fs13.lstat(sourceEntryPath);
+    if (entryStats.isSymbolicLink()) {
+      throw new Error(`Refusing to copy source symlink at ${sourceEntryPath}`);
+    }
+    if (entryStats.isDirectory()) {
+      await copyDirectoryContents(sourceEntryPath, targetEntryPath);
+      continue;
+    }
+    if (entryStats.isFile()) {
+      await fs13.mkdir(dirname3(targetEntryPath), { recursive: true });
+      await fs13.copyFile(sourceEntryPath, targetEntryPath);
+      continue;
+    }
+    throw new Error(`Unsupported filesystem entry at ${sourceEntryPath}`);
+  }
+}
+async function assertSkillSourceLayout(sourcePath) {
+  const resolvedSourcePath = resolve7(sourcePath);
+  const skillFilePath = join8(resolvedSourcePath, "SKILL.md");
+  await assertNoSymlinkAncestors(resolvedSourcePath, { includeLeaf: true });
+  await assertDirectory(resolvedSourcePath);
+  try {
+    await assertRegularFile(skillFilePath, "SKILL.md");
+  } catch (error) {
+    if (error.code === "ENOENT") {
+      throw new Error(`Refusing to import ${resolvedSourcePath} without a root SKILL.md`);
+    }
+    throw error;
+  }
+}
+async function copySkillContentsToManagedStore(sourcePath, targetPath) {
+  const resolvedSourcePath = resolve7(sourcePath);
+  const resolvedTargetPath = resolve7(targetPath);
+  if (pathsAreEqual(resolvedSourcePath, resolvedTargetPath)) {
+    throw new Error("Source and target paths must differ");
+  }
+  if (isPathInside(resolvedSourcePath, resolvedTargetPath)) {
+    throw new Error("Refusing to copy into a child of the source directory");
+  }
+  await assertSkillSourceLayout(resolvedSourcePath);
+  await assertNoSymlinkAncestors(resolvedTargetPath);
+  await assertTargetDoesNotExist(resolvedTargetPath);
+  await copyDirectoryContents(resolvedSourcePath, resolvedTargetPath);
+}
+
+// src/commands/import.ts
+function buildManagedSkillPath(skillmuxHome, skillId) {
+  return resolve8(skillmuxHome, "skills", skillId);
+}
+async function runImport(options) {
+  const homeDir = options.homeDir ?? homedir6();
+  const resolvedPaths = resolveSkillmuxHome(homeDir);
+  const skillmuxHome = options.skillmuxHome ?? resolvedPaths.skillmuxHome;
+  const sourcePath = resolve8(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/scan.ts
+import { homedir as homedir7 } from "os";
+
+// src/output/format-issue.ts
+function formatIssue(issue) {
+  if (issue.path === void 0) {
+    return `[${issue.severity}] ${issue.code}: ${issue.message}`;
+  }
+  return `[${issue.severity}] ${issue.code} @ ${issue.path}: ${issue.message}`;
+}
+
+// src/commands/scan.ts
+function buildAgentRecord3(agent, timestamp, previousRecord) {
+  const lastSeenAt = agent.exists ? timestamp : previousRecord?.lastSeenAt ?? null;
+  return {
+    id: agent.id,
+    name: agent.stableName,
+    path: agent.absoluteSkillsDirectoryPath,
+    discovery: agent.discovery,
+    available: agent.exists && agent.supportedOnPlatform,
+    lastSeenAt
+  };
+}
+function buildScanOutput(result, json) {
+  if (json) {
+    return printJson({
+      lastScan: result.manifest.lastScan,
+      agents: result.agents.map((agent) => ({
+        id: agent.id,
+        name: agent.stableName,
+        path: agent.absoluteSkillsDirectoryPath,
+        exists: agent.exists,
+        supportedOnPlatform: agent.supportedOnPlatform
+      })),
+      entries: result.entries
+    });
+  }
+  if (result.entries.length === 0) {
+    return "No skill entries found.\n";
+  }
+  const table = printTable(
+    result.entries.map((entry) => ({
+      agent: entry.agentId,
+      skill: entry.skillName,
+      kind: entry.kind,
+      path: entry.path
+    })),
+    [
+      { key: "agent", label: "Agent" },
+      { key: "skill", label: "Skill" },
+      { key: "kind", label: "Kind" },
+      { key: "path", label: "Path" }
+    ]
+  );
+  if (result.issues.length === 0) {
+    return table;
+  }
+  return `${table}
+${result.issues.map(formatIssue).join("\n")}
+`;
+}
+async function runScan(options = {}) {
+  const homeDir = options.homeDir ?? homedir7();
+  const resolvedPaths = resolveSkillmuxHome(homeDir);
+  const skillmuxHome = options.skillmuxHome ?? resolvedPaths.skillmuxHome;
+  const manifest = await readManifest(skillmuxHome);
+  const agents = await discoverAgents({
+    homeDir,
+    platform: options.platform,
+    skillmuxHome
+  });
+  const timestamp = (options.now ?? /* @__PURE__ */ new Date()).toISOString();
+  const entries = [];
+  const issues = [];
+  for (const agent of agents) {
+    const scannedAgent = await scanAgentSkills(agent, skillmuxHome);
+    entries.push(...scannedAgent.entries);
+    issues.push(...scannedAgent.issues);
+    manifest.agents[agent.id] = buildAgentRecord3(
+      agent,
+      timestamp,
+      manifest.agents[agent.id]
+    );
+  }
+  manifest.lastScan = {
+    at: timestamp,
+    issues
+  };
+  await writeManifest(skillmuxHome, manifest);
+  const resultWithoutOutput = {
+    manifest,
+    agents,
+    entries,
+    issues
+  };
+  return {
+    ...resultWithoutOutput,
+    output: buildScanOutput(resultWithoutOutput, options.json === true)
+  };
+}
+
+// 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 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 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 buildTableOutput4(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) : buildTableOutput4(data, view)
+  };
+}
+
+// src/index.ts
+function buildCli() {
+  const program = new Command();
+  program.name("skillmux");
+  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("config").option("--json", "Emit structured JSON output").action(async (options) => {
+    const result = await runConfig({ json: options.json === true });
+    process.stdout.write(result.output);
+  });
+  program.command("enable").requiredOption("--skill <skill>", "Managed skill name or id").requiredOption("--agent <agent>", "Target agent id").action(async (options) => {
+    const result = await runEnable({
+      skill: options.skill,
+      agent: options.agent
+    });
+    process.stdout.write(result.output);
+  });
+  program.command("disable").requiredOption("--skill <skill>", "Managed skill name or id").requiredOption("--agent <agent>", "Target agent id").action(async (options) => {
+    const result = await runDisable({
+      skill: options.skill,
+      agent: options.agent
+    });
+    process.stdout.write(result.output);
+  });
+  return program;
+}
+export {
+  buildCli
+};
+//# sourceMappingURL=index.js.map