@braid-cloud/cli 0.1.0

package/dist/index.js

@@ -0,0 +1,1780 @@
+#!/usr/bin/env node
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// ../../node_modules/tsup/assets/esm_shims.js
+import path from "path";
+import { fileURLToPath } from "url";
+var init_esm_shims = __esm({
+  "../../node_modules/tsup/assets/esm_shims.js"() {
+    "use strict";
+  }
+});
+
+// src/lib/config.ts
+var config_exports = {};
+__export(config_exports, {
+  CONFIG_DIR: () => CONFIG_DIR,
+  CONFIG_FILE: () => CONFIG_FILE,
+  ConfigReadError: () => ConfigReadError,
+  ConfigWriteError: () => ConfigWriteError,
+  PROJECT_CONFIG_FILENAME: () => PROJECT_CONFIG_FILENAME,
+  USER_CONFIG_FILENAME: () => USER_CONFIG_FILENAME,
+  clearApiKey: () => clearApiKey,
+  clearApiKeyAsync: () => clearApiKeyAsync,
+  findProjectConfigFile: () => findProjectConfigFile,
+  findProjectConfigFileAsync: () => findProjectConfigFileAsync,
+  findUserConfigFile: () => findUserConfigFile,
+  findUserConfigFileAsync: () => findUserConfigFileAsync,
+  getApiKey: () => getApiKey,
+  getApiKeyAsync: () => getApiKeyAsync,
+  getServerUrl: () => getServerUrl,
+  getServerUrlAsync: () => getServerUrlAsync,
+  loadConfig: () => loadConfig,
+  loadConfigAsync: () => loadConfigAsync,
+  loadMergedConfig: () => loadMergedConfig,
+  loadMergedConfigAsync: () => loadMergedConfigAsync,
+  loadProjectConfig: () => loadProjectConfig,
+  loadProjectConfigAsync: () => loadProjectConfigAsync,
+  loadUserConfig: () => loadUserConfig,
+  loadUserConfigAsync: () => loadUserConfigAsync,
+  saveConfig: () => saveConfig,
+  saveConfigAsync: () => saveConfigAsync,
+  setApiKey: () => setApiKey,
+  setApiKeyAsync: () => setApiKeyAsync
+});
+import { existsSync } from "fs";
+import { mkdir, readFile, writeFile } from "fs/promises";
+import { homedir } from "os";
+import { dirname, join, parse } from "path";
+import process2 from "process";
+import { Data, Effect, pipe } from "effect";
+var CONFIG_DIR, CONFIG_FILE, PROJECT_CONFIG_FILENAME, USER_CONFIG_FILENAME, ConfigReadError, ConfigWriteError, findConfigFile, findProjectConfigFile, findUserConfigFile, loadProjectConfig, loadUserConfig, resolveServerUrlFromConfig, applyConfigSource, applyEnvOverrides, createDefaultMergedConfig, loadMergedConfig, loadConfig, saveConfig, getApiKey, setApiKey, getServerUrl, clearApiKey, loadConfigAsync, loadProjectConfigAsync, loadUserConfigAsync, loadMergedConfigAsync, findProjectConfigFileAsync, findUserConfigFileAsync, saveConfigAsync, getApiKeyAsync, setApiKeyAsync, getServerUrlAsync, clearApiKeyAsync;
+var init_config = __esm({
+  "src/lib/config.ts"() {
+    "use strict";
+    init_esm_shims();
+    CONFIG_DIR = join(homedir(), ".config", "braid-skills");
+    CONFIG_FILE = join(CONFIG_DIR, "config.json");
+    PROJECT_CONFIG_FILENAME = "braid.json";
+    USER_CONFIG_FILENAME = "braid.user.json";
+    ConfigReadError = class extends Data.TaggedError("ConfigReadError") {
+    };
+    ConfigWriteError = class extends Data.TaggedError("ConfigWriteError") {
+    };
+    findConfigFile = (filename, startDir = process2.cwd()) => {
+      let currentDir = startDir;
+      while (true) {
+        const configPath = join(currentDir, filename);
+        if (existsSync(configPath)) {
+          return configPath;
+        }
+        const parsed = parse(currentDir);
+        if (parsed.root === currentDir) {
+          return void 0;
+        }
+        currentDir = parsed.dir;
+      }
+    };
+    findProjectConfigFile = (startDir = process2.cwd()) => findConfigFile(PROJECT_CONFIG_FILENAME, startDir);
+    findUserConfigFile = (startDir = process2.cwd()) => findConfigFile(USER_CONFIG_FILENAME, startDir);
+    loadProjectConfig = () => Effect.tryPromise({
+      try: async () => {
+        const configPath = await findProjectConfigFile();
+        if (!configPath) {
+          return void 0;
+        }
+        const content = await readFile(configPath, "utf-8");
+        return JSON.parse(content);
+      },
+      catch: () => void 0
+    }).pipe(Effect.orElseSucceed(() => void 0));
+    loadUserConfig = () => Effect.tryPromise({
+      try: async () => {
+        const configPath = await findUserConfigFile();
+        if (!configPath) {
+          return void 0;
+        }
+        const content = await readFile(configPath, "utf-8");
+        return JSON.parse(content);
+      },
+      catch: () => void 0
+    }).pipe(Effect.orElseSucceed(() => void 0));
+    resolveServerUrlFromConfig = (config) => {
+      if (!config) {
+        return void 0;
+      }
+      return config.skills?.serverUrl ?? config.serverUrl;
+    };
+    applyConfigSource = (merged, config) => {
+      if (!config) {
+        return;
+      }
+      const serverUrl = resolveServerUrlFromConfig(config);
+      if (serverUrl) {
+        merged.serverUrl = serverUrl;
+      }
+      if (config.profile) {
+        merged.profile = config.profile;
+      }
+      if (config.orgProjects) {
+        merged.orgProjects = config.orgProjects;
+      }
+      if (config.personalProjects) {
+        merged.personalProjects = config.personalProjects;
+      }
+      if (config.includeUserGlobalRules !== void 0) {
+        merged.includeUserGlobalRules = config.includeUserGlobalRules;
+      }
+      if (config.includeOrgGlobalRules !== void 0) {
+        merged.includeOrgGlobalRules = config.includeOrgGlobalRules;
+      }
+      if (config.agents) {
+        merged.agents = config.agents;
+      }
+      if ("token" in config && config.token) {
+        merged.token = config.token;
+      }
+    };
+    applyEnvOverrides = (merged) => {
+      if (process2.env.BRAID_API_KEY) {
+        merged.token = process2.env.BRAID_API_KEY;
+      }
+      const envServerUrl = process2.env.BRAID_SKILLS_SERVER_URL ?? process2.env.BRAID_SERVER_URL;
+      if (envServerUrl) {
+        merged.serverUrl = envServerUrl;
+      }
+    };
+    createDefaultMergedConfig = () => ({
+      serverUrl: "https://braid.cloud",
+      includeUserGlobalRules: true,
+      includeOrgGlobalRules: true
+    });
+    loadMergedConfig = () => pipe(
+      Effect.all({
+        projectConfig: loadProjectConfig(),
+        userConfig: loadUserConfig(),
+        globalConfig: loadConfig().pipe(
+          Effect.orElseSucceed(() => ({}))
+        )
+      }),
+      Effect.map(({ projectConfig, userConfig, globalConfig }) => {
+        const merged = createDefaultMergedConfig();
+        applyConfigSource(merged, projectConfig);
+        applyConfigSource(merged, userConfig);
+        applyEnvOverrides(merged);
+        if (!merged.token && globalConfig.apiKey) {
+          merged.token = globalConfig.apiKey;
+        }
+        return merged;
+      })
+    );
+    loadConfig = () => pipe(
+      Effect.tryPromise({
+        try: () => readFile(CONFIG_FILE, "utf-8"),
+        catch: (e) => new ConfigReadError({ path: CONFIG_FILE, cause: e })
+      }),
+      Effect.flatMap(
+        (content) => Effect.try({
+          try: () => JSON.parse(content),
+          catch: () => ({})
+        })
+      ),
+      Effect.orElseSucceed(() => ({}))
+    );
+    saveConfig = (config) => pipe(
+      Effect.tryPromise({
+        try: async () => {
+          await mkdir(dirname(CONFIG_FILE), { recursive: true });
+          await writeFile(CONFIG_FILE, JSON.stringify(config, null, 2), "utf-8");
+        },
+        catch: (e) => new ConfigWriteError({ path: CONFIG_FILE, cause: e })
+      })
+    );
+    getApiKey = () => pipe(
+      Effect.succeed(process2.env.BRAID_API_KEY),
+      Effect.flatMap(
+        (envKey) => envKey ? Effect.succeed(envKey) : pipe(
+          loadUserConfig(),
+          Effect.flatMap(
+            (userConfig) => userConfig?.token ? Effect.succeed(userConfig.token) : pipe(
+              loadConfig(),
+              Effect.map((config) => config.apiKey)
+            )
+          )
+        )
+      )
+    );
+    setApiKey = (apiKey) => pipe(
+      loadConfig(),
+      Effect.flatMap((config) => saveConfig({ ...config, apiKey }))
+    );
+    getServerUrl = () => pipe(
+      Effect.succeed(process2.env.BRAID_SERVER_URL),
+      Effect.flatMap(
+        (envUrl) => envUrl ? Effect.succeed(envUrl) : pipe(
+          loadUserConfig(),
+          Effect.flatMap(
+            (userConfig) => userConfig?.serverUrl ? Effect.succeed(userConfig.serverUrl) : pipe(
+              loadConfig(),
+              Effect.map(
+                (config) => config.serverUrl ?? "https://braid.cloud"
+              )
+            )
+          )
+        )
+      )
+    );
+    clearApiKey = () => pipe(
+      loadConfig(),
+      Effect.flatMap((config) => {
+        const { apiKey: _, ...rest } = config;
+        return saveConfig(rest);
+      })
+    );
+    loadConfigAsync = () => Effect.runPromise(loadConfig());
+    loadProjectConfigAsync = () => Effect.runPromise(loadProjectConfig());
+    loadUserConfigAsync = () => Effect.runPromise(loadUserConfig());
+    loadMergedConfigAsync = () => Effect.runPromise(loadMergedConfig());
+    findProjectConfigFileAsync = (startDir) => findProjectConfigFile(startDir);
+    findUserConfigFileAsync = (startDir) => findUserConfigFile(startDir);
+    saveConfigAsync = (config) => Effect.runPromise(saveConfig(config));
+    getApiKeyAsync = () => Effect.runPromise(getApiKey());
+    setApiKeyAsync = (apiKey) => Effect.runPromise(setApiKey(apiKey));
+    getServerUrlAsync = () => Effect.runPromise(getServerUrl());
+    clearApiKeyAsync = () => Effect.runPromise(clearApiKey());
+  }
+});
+
+// src/index.ts
+init_esm_shims();
+import { Command } from "commander";
+
+// src/commands/auth.ts
+init_esm_shims();
+import process3 from "process";
+import {
+  cancel,
+  confirm,
+  intro,
+  isCancel,
+  log,
+  outro,
+  password,
+  spinner
+} from "@clack/prompts";
+
+// src/lib/api.ts
+init_esm_shims();
+init_config();
+import { Data as Data2, Effect as Effect2, pipe as pipe2 } from "effect";
+var TRAILING_SLASH_REGEX = /\/$/;
+var ApiError = class extends Data2.TaggedError("ApiError") {
+};
+var AuthenticationError = class extends Data2.TaggedError("AuthenticationError") {
+};
+var NetworkError = class extends Data2.TaggedError("NetworkError") {
+};
+var resolveApiKey = (optionsApiKey) => {
+  if (optionsApiKey) {
+    return Effect2.succeed(optionsApiKey);
+  }
+  return pipe2(
+    Effect2.tryPromise({
+      try: () => getApiKeyAsync(),
+      catch: () => new NetworkError({ message: "Failed to read config" })
+    }),
+    Effect2.flatMap(
+      (key) => key ? Effect2.succeed(key) : Effect2.fail(
+        new AuthenticationError({
+          message: 'No API key configured. Run "pvskills auth" to authenticate.'
+        })
+      )
+    )
+  );
+};
+var resolveServerUrl = (optionsServerUrl) => {
+  if (optionsServerUrl) {
+    return Effect2.succeed(optionsServerUrl);
+  }
+  return Effect2.tryPromise({
+    try: () => getServerUrlAsync(),
+    catch: () => new NetworkError({ message: "Failed to read config" })
+  });
+};
+var parseResponse = (response, json) => {
+  if (!response.ok) {
+    const errorResponse = json;
+    if (response.status === 401) {
+      return Effect2.fail(
+        new AuthenticationError({
+          message: errorResponse.error || "Invalid or expired API key. Run 'pvskills auth' to re-authenticate."
+        })
+      );
+    }
+    return Effect2.fail(
+      new ApiError({
+        message: errorResponse.error || "API request failed",
+        code: errorResponse.code || "UNKNOWN_ERROR",
+        status: response.status
+      })
+    );
+  }
+  return Effect2.succeed(json);
+};
+var buildApiUrl = (serverUrl, path2) => {
+  const baseUrl = serverUrl.replace(TRAILING_SLASH_REGEX, "");
+  return new URL(`${baseUrl}${path2}`);
+};
+var buildExportUrl = (serverUrl, options) => {
+  const url = buildApiUrl(serverUrl, "/api/skills/export");
+  if (options.profile) {
+    url.searchParams.set("profile", options.profile);
+  }
+  if (options.orgProjects && options.orgProjects.length > 0) {
+    url.searchParams.set("orgProjects", options.orgProjects.join(","));
+  }
+  if (options.personalProjects && options.personalProjects.length > 0) {
+    url.searchParams.set(
+      "personalProjects",
+      options.personalProjects.join(",")
+    );
+  }
+  if (options.includeUserGlobalRules !== void 0) {
+    url.searchParams.set(
+      "includeUserGlobal",
+      String(options.includeUserGlobalRules)
+    );
+  }
+  if (options.includeOrgGlobalRules !== void 0) {
+    url.searchParams.set(
+      "includeOrgGlobal",
+      String(options.includeOrgGlobalRules)
+    );
+  }
+  return url;
+};
+var executeApiRequest = (url, apiKey, serverUrl) => pipe2(
+  Effect2.tryPromise({
+    try: () => fetch(url.toString(), {
+      method: "GET",
+      headers: {
+        Authorization: `Bearer ${apiKey}`,
+        "Content-Type": "application/json"
+      }
+    }),
+    catch: (e) => new NetworkError({
+      message: `Failed to connect to ${serverUrl}`,
+      cause: e
+    })
+  }),
+  Effect2.flatMap(
+    (response) => pipe2(
+      Effect2.tryPromise({
+        try: () => response.json(),
+        catch: () => new NetworkError({ message: "Failed to parse API response" })
+      }),
+      Effect2.flatMap((json) => parseResponse(response, json))
+    )
+  )
+);
+var fetchSkills = (options) => pipe2(
+  Effect2.all({
+    apiKey: resolveApiKey(options.apiKey),
+    serverUrl: resolveServerUrl(options.serverUrl)
+  }),
+  Effect2.flatMap(({ apiKey, serverUrl }) => {
+    const url = buildExportUrl(serverUrl, options);
+    return executeApiRequest(url, apiKey, serverUrl);
+  })
+);
+var validateApiKey = (apiKey, serverUrl) => pipe2(
+  Effect2.tryPromise({
+    try: async () => {
+      const baseUrl = serverUrl ?? "https://braid.cloud";
+      const url = buildApiUrl(baseUrl, "/api/skills/export");
+      url.searchParams.set("profile", "default");
+      const response = await fetch(url.toString(), {
+        method: "GET",
+        headers: {
+          Authorization: `Bearer ${apiKey}`,
+          "Content-Type": "application/json"
+        }
+      });
+      return response.status !== 401;
+    },
+    catch: (e) => new NetworkError({
+      message: `Failed to connect to ${serverUrl ?? "https://braid.cloud"}`,
+      cause: e
+    })
+  })
+);
+var fetchSkillsAsync = (options) => Effect2.runPromise(fetchSkills(options));
+var validateApiKeyAsync = (apiKey, serverUrl) => Effect2.runPromise(validateApiKey(apiKey, serverUrl));
+
+// src/commands/auth.ts
+init_config();
+async function authCommand(options) {
+  intro("braid-skills auth");
+  const config = await loadMergedConfigAsync();
+  if (config.token) {
+    const shouldReplace = await confirm({
+      message: "An API key is already configured. Replace it?",
+      initialValue: false
+    });
+    if (isCancel(shouldReplace) || !shouldReplace) {
+      outro("Auth cancelled.");
+      return;
+    }
+  }
+  const apiKey = await password({
+    message: "Enter your Braid API key:",
+    validate: (value) => {
+      if (!value) {
+        return "API key is required";
+      }
+      if (!value.startsWith("br_")) {
+        return "API key should start with 'br_'";
+      }
+      return void 0;
+    }
+  });
+  if (isCancel(apiKey)) {
+    cancel("Auth cancelled.");
+    process3.exit(0);
+  }
+  const authSpinner = spinner();
+  authSpinner.start("Validating API key...");
+  try {
+    const serverUrl = options.server ?? "https://braid.cloud";
+    const isValid = await validateApiKeyAsync(apiKey, serverUrl);
+    if (!isValid) {
+      authSpinner.stop("Invalid API key");
+      log.error(
+        "The API key could not be validated. Please check your key and try again."
+      );
+      process3.exit(1);
+    }
+    await setApiKeyAsync(apiKey);
+    authSpinner.stop("API key validated and saved");
+    log.success(`Config saved to ${CONFIG_FILE}`);
+    outro(
+      "You're authenticated! Run 'braid-skills install --profile <name>' to install skills."
+    );
+  } catch (error) {
+    authSpinner.stop("Validation failed");
+    const message = error instanceof Error ? error.message : String(error);
+    log.error(`Failed to validate API key: ${message}`);
+    process3.exit(1);
+  }
+}
+async function displayTokenSource(masked) {
+  if (process3.env.BRAID_API_KEY) {
+    log.info(`Authenticated with key: ${masked}`);
+    log.info("Source: BRAID_API_KEY environment variable");
+    return;
+  }
+  const userConfigPath = await findUserConfigFileAsync();
+  log.info(`Authenticated with key: ${masked}`);
+  log.info(`Source: ${userConfigPath ?? CONFIG_FILE}`);
+}
+async function displayProjectConfig() {
+  const projectConfigPath = await findProjectConfigFileAsync();
+  if (projectConfigPath) {
+    log.info(`Project config: ${projectConfigPath}`);
+  }
+}
+function displayResolvedSettings(config) {
+  const hasOrgProjects = config.orgProjects && config.orgProjects.length > 0;
+  const hasPersonalProjects = config.personalProjects && config.personalProjects.length > 0;
+  if (!(config.profile || hasOrgProjects || hasPersonalProjects)) {
+    return;
+  }
+  log.info("");
+  if (config.profile) {
+    log.info(`Default profile: ${config.profile}`);
+  }
+  if (hasOrgProjects) {
+    log.info(`Org projects: ${config.orgProjects?.join(", ")}`);
+  }
+  if (hasPersonalProjects) {
+    log.info(`Personal projects: ${config.personalProjects?.join(", ")}`);
+  }
+  if (config.serverUrl !== "https://braid.cloud") {
+    log.info(`Server: ${config.serverUrl}`);
+  }
+}
+async function authStatusCommand() {
+  const config = await loadMergedConfigAsync();
+  if (!config.token) {
+    log.warn(
+      "Not authenticated. Run 'braid-skills auth' to configure your API key."
+    );
+    log.info(
+      `Or create a ${USER_CONFIG_FILENAME} file with: { "token": "br_xxx" }`
+    );
+    return;
+  }
+  const masked = `${config.token.slice(0, 7)}...${config.token.slice(-4)}`;
+  await displayTokenSource(masked);
+  await displayProjectConfig();
+  displayResolvedSettings(config);
+}
+async function authLogoutCommand() {
+  const { clearApiKeyAsync: clearApiKeyAsync2 } = await Promise.resolve().then(() => (init_config(), config_exports));
+  await clearApiKeyAsync2();
+  log.success("Logged out. API key removed from config.");
+}
+
+// src/commands/install.ts
+init_esm_shims();
+
+// src/lib/agents.ts
+init_esm_shims();
+import { access, constants } from "fs/promises";
+import { homedir as homedir2 } from "os";
+import { join as join2 } from "path";
+import process4 from "process";
+import { Effect as Effect3, pipe as pipe3 } from "effect";
+var home = homedir2();
+var AGENTS = [
+  {
+    id: "amp",
+    name: "Amp, Kimi Code CLI",
+    projectPath: ".agents/skills",
+    globalPath: join2(home, ".config", "agents", "skills")
+  },
+  {
+    id: "kimi-cli",
+    name: "Kimi Code CLI",
+    projectPath: ".agents/skills",
+    globalPath: join2(home, ".config", "agents", "skills")
+  },
+  {
+    id: "antigravity",
+    name: "Antigravity",
+    projectPath: ".agent/skills",
+    globalPath: join2(home, ".gemini", "antigravity", "global_skills")
+  },
+  {
+    id: "claude-code",
+    name: "Claude Code",
+    projectPath: ".claude/skills",
+    globalPath: join2(home, ".claude", "skills")
+  },
+  {
+    id: "moltbot",
+    name: "Moltbot",
+    projectPath: "skills",
+    globalPath: join2(home, ".moltbot", "skills")
+  },
+  {
+    id: "cline",
+    name: "Cline",
+    projectPath: ".cline/skills",
+    globalPath: join2(home, ".cline", "skills")
+  },
+  {
+    id: "codebuddy",
+    name: "CodeBuddy",
+    projectPath: ".codebuddy/skills",
+    globalPath: join2(home, ".codebuddy", "skills")
+  },
+  {
+    id: "codex",
+    name: "Codex",
+    projectPath: ".codex/skills",
+    globalPath: join2(home, ".codex", "skills")
+  },
+  {
+    id: "command-code",
+    name: "Command Code",
+    projectPath: ".commandcode/skills",
+    globalPath: join2(home, ".commandcode", "skills")
+  },
+  {
+    id: "continue",
+    name: "Continue",
+    projectPath: ".continue/skills",
+    globalPath: join2(home, ".continue", "skills")
+  },
+  {
+    id: "crush",
+    name: "Crush",
+    projectPath: ".crush/skills",
+    globalPath: join2(home, ".config", "crush", "skills")
+  },
+  {
+    id: "cursor",
+    name: "Cursor",
+    projectPath: ".cursor/skills",
+    globalPath: join2(home, ".cursor", "skills")
+  },
+  {
+    id: "droid",
+    name: "Droid",
+    projectPath: ".factory/skills",
+    globalPath: join2(home, ".factory", "skills")
+  },
+  {
+    id: "gemini-cli",
+    name: "Gemini CLI",
+    projectPath: ".gemini/skills",
+    globalPath: join2(home, ".gemini", "skills")
+  },
+  {
+    id: "github-copilot",
+    name: "GitHub Copilot",
+    projectPath: ".github/skills",
+    globalPath: join2(home, ".copilot", "skills")
+  },
+  {
+    id: "goose",
+    name: "Goose",
+    projectPath: ".goose/skills",
+    globalPath: join2(home, ".config", "goose", "skills")
+  },
+  {
+    id: "junie",
+    name: "Junie",
+    projectPath: ".junie/skills",
+    globalPath: join2(home, ".junie", "skills")
+  },
+  {
+    id: "kilo",
+    name: "Kilo Code",
+    projectPath: ".kilocode/skills",
+    globalPath: join2(home, ".kilocode", "skills")
+  },
+  {
+    id: "kiro-cli",
+    name: "Kiro CLI",
+    projectPath: ".kiro/skills",
+    globalPath: join2(home, ".kiro", "skills")
+  },
+  {
+    id: "kode",
+    name: "Kode",
+    projectPath: ".kode/skills",
+    globalPath: join2(home, ".kode", "skills")
+  },
+  {
+    id: "mcpjam",
+    name: "MCPJam",
+    projectPath: ".mcpjam/skills",
+    globalPath: join2(home, ".mcpjam", "skills")
+  },
+  {
+    id: "mux",
+    name: "Mux",
+    projectPath: ".mux/skills",
+    globalPath: join2(home, ".mux", "skills")
+  },
+  {
+    id: "opencode",
+    name: "OpenCode",
+    projectPath: ".opencode/skills",
+    globalPath: join2(home, ".config", "opencode", "skills")
+  },
+  {
+    id: "openhands",
+    name: "OpenHands",
+    projectPath: ".openhands/skills",
+    globalPath: join2(home, ".openhands", "skills")
+  },
+  {
+    id: "pi",
+    name: "Pi",
+    projectPath: ".pi/skills",
+    globalPath: join2(home, ".pi", "agent", "skills")
+  },
+  {
+    id: "qoder",
+    name: "Qoder",
+    projectPath: ".qoder/skills",
+    globalPath: join2(home, ".qoder", "skills")
+  },
+  {
+    id: "qwen-code",
+    name: "Qwen Code",
+    projectPath: ".qwen/skills",
+    globalPath: join2(home, ".qwen", "skills")
+  },
+  {
+    id: "roo",
+    name: "Roo Code",
+    projectPath: ".roo/skills",
+    globalPath: join2(home, ".roo", "skills")
+  },
+  {
+    id: "trae",
+    name: "Trae",
+    projectPath: ".trae/skills",
+    globalPath: join2(home, ".trae", "skills")
+  },
+  {
+    id: "windsurf",
+    name: "Windsurf",
+    projectPath: ".windsurf/skills",
+    globalPath: join2(home, ".codeium", "windsurf", "skills")
+  },
+  {
+    id: "zencoder",
+    name: "Zencoder",
+    projectPath: ".zencoder/skills",
+    globalPath: join2(home, ".zencoder", "skills")
+  },
+  {
+    id: "neovate",
+    name: "Neovate",
+    projectPath: ".neovate/skills",
+    globalPath: join2(home, ".neovate", "skills")
+  },
+  {
+    id: "pochi",
+    name: "Pochi",
+    projectPath: ".pochi/skills",
+    globalPath: join2(home, ".pochi", "skills")
+  }
+];
+var directoryExists = (path2) => pipe3(
+  Effect3.tryPromise({
+    try: () => access(path2, constants.F_OK),
+    catch: () => false
+  }),
+  Effect3.map(() => true),
+  Effect3.orElseSucceed(() => false)
+);
+var getAgentConfigDir = (skillsPath) => {
+  const parts = skillsPath.split("/");
+  return parts.slice(0, -1).join("/");
+};
+var detectAgents = (projectRoot) => {
+  const cwd = projectRoot ?? process4.cwd();
+  return pipe3(
+    Effect3.forEach(
+      AGENTS,
+      (agent) => pipe3(
+        Effect3.all({
+          hasProjectConfig: directoryExists(
+            join2(cwd, getAgentConfigDir(agent.projectPath))
+          ),
+          hasGlobalConfig: directoryExists(getAgentConfigDir(agent.globalPath))
+        }),
+        Effect3.map(
+          ({ hasProjectConfig, hasGlobalConfig }) => ({
+            ...agent,
+            hasProjectConfig,
+            hasGlobalConfig
+          })
+        )
+      )
+    ),
+    Effect3.map(
+      (agents) => agents.filter((a) => a.hasProjectConfig || a.hasGlobalConfig)
+    )
+  );
+};
+var getAgentById = (id) => AGENTS.find((a) => a.id === id);
+var detectAgentsAsync = (projectRoot) => Effect3.runPromise(detectAgents(projectRoot));
+var directoryExistsAsync = (path2) => Effect3.runPromise(directoryExists(path2));
+var resolveInstallPath = (agent, options) => {
+  if (options.global) {
+    return agent.globalPath;
+  }
+  const cwd = options.projectRoot ?? process4.cwd();
+  return join2(cwd, agent.projectPath);
+};
+
+// src/commands/install.ts
+init_config();
+
+// src/lib/metadata.ts
+init_esm_shims();
+import { readFile as readFile2, writeFile as writeFile2 } from "fs/promises";
+import { join as join3 } from "path";
+import { Data as Data3, Effect as Effect4, pipe as pipe4 } from "effect";
+var METADATA_FILENAME = ".braidskills-metadata.json";
+var MetadataReadError = class extends Data3.TaggedError("MetadataReadError") {
+};
+var MetadataWriteError = class extends Data3.TaggedError("MetadataWriteError") {
+};
+var getMetadataPath = (skillsDir) => join3(skillsDir, METADATA_FILENAME);
+var readMetadata = (skillsDir) => {
+  const metadataPath = getMetadataPath(skillsDir);
+  return pipe4(
+    Effect4.tryPromise({
+      try: () => readFile2(metadataPath, "utf-8"),
+      catch: (e) => new MetadataReadError({ path: metadataPath, cause: e })
+    }),
+    Effect4.flatMap(
+      (content) => Effect4.try({
+        try: () => JSON.parse(content),
+        catch: () => ({ skills: [] })
+      })
+    ),
+    Effect4.orElseSucceed(() => ({ skills: [] }))
+  );
+};
+var writeMetadata = (skillsDir, metadata) => {
+  const metadataPath = getMetadataPath(skillsDir);
+  return Effect4.tryPromise({
+    try: () => writeFile2(metadataPath, JSON.stringify(metadata, null, 2), "utf-8"),
+    catch: (e) => new MetadataWriteError({ path: metadataPath, cause: e })
+  });
+};
+var updateMetadata = (skillsDir, newSkills) => pipe4(
+  readMetadata(skillsDir),
+  Effect4.map((existing) => {
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const updatedSkills = [...existing.skills];
+    for (const skill of newSkills) {
+      const existingIndex = updatedSkills.findIndex(
+        (s) => s.name === skill.name
+      );
+      const newEntry = {
+        name: skill.name,
+        source: skill.source,
+        version: skill.version,
+        installedAt: now,
+        serverUrl: skill.serverUrl
+      };
+      if (existingIndex >= 0) {
+        updatedSkills[existingIndex] = newEntry;
+      } else {
+        updatedSkills.push(newEntry);
+      }
+    }
+    return { skills: updatedSkills };
+  }),
+  Effect4.flatMap((metadata) => writeMetadata(skillsDir, metadata))
+);
+var removeFromMetadata = (skillsDir, skillName) => pipe4(
+  readMetadata(skillsDir),
+  Effect4.map((metadata) => ({
+    skills: metadata.skills.filter((s) => s.name !== skillName)
+  })),
+  Effect4.flatMap((metadata) => writeMetadata(skillsDir, metadata))
+);
+var readMetadataAsync = (skillsDir) => Effect4.runPromise(readMetadata(skillsDir));
+var updateMetadataAsync = (skillsDir, newSkills) => Effect4.runPromise(updateMetadata(skillsDir, newSkills));
+var removeFromMetadataAsync = (skillsDir, skillName) => Effect4.runPromise(removeFromMetadata(skillsDir, skillName));
+
+// src/lib/skill-writer.ts
+init_esm_shims();
+import { mkdir as mkdir2, writeFile as writeFile3 } from "fs/promises";
+import { dirname as dirname2, join as join4 } from "path";
+import { Data as Data4, Effect as Effect5, pipe as pipe5 } from "effect";
+var WriteError = class extends Data4.TaggedError("WriteError") {
+};
+var COMPATIBILITY_REGEX = /^compatibility:\s*.+$/m;
+var rewriteCompatibility = (content, agentId) => {
+  return content.replace(COMPATIBILITY_REGEX, `compatibility: ${agentId}`);
+};
+var decodeFileContent = (file, agentId) => {
+  let content;
+  if (file.encoding === "base64") {
+    content = Buffer.from(file.content, "base64").toString("utf-8");
+  } else {
+    content = file.content;
+  }
+  if (agentId && file.path === "SKILL.md") {
+    content = rewriteCompatibility(content, agentId);
+  }
+  return content;
+};
+var decodeFileContentBinary = (file) => {
+  if (file.encoding === "base64") {
+    return Buffer.from(file.content, "base64");
+  }
+  return Buffer.from(file.content, "utf-8");
+};
+var isBinaryFile = (path2) => {
+  const binaryExtensions = [
+    ".png",
+    ".jpg",
+    ".jpeg",
+    ".gif",
+    ".webp",
+    ".ico",
+    ".bmp"
+  ];
+  return binaryExtensions.some((ext) => path2.toLowerCase().endsWith(ext));
+};
+var writeSkillFile = (basePath, file, agentId) => pipe5(
+  Effect5.tryPromise({
+    try: async () => {
+      const fullPath = join4(basePath, file.path);
+      const dir = dirname2(fullPath);
+      await mkdir2(dir, { recursive: true });
+      if (isBinaryFile(file.path)) {
+        await writeFile3(fullPath, decodeFileContentBinary(file));
+      } else {
+        await writeFile3(fullPath, decodeFileContent(file, agentId), "utf-8");
+      }
+    },
+    catch: (e) => new WriteError({ path: join4(basePath, file.path), cause: e })
+  })
+);
+var writeSkill = (basePath, skill, agentId) => {
+  const skillDir = join4(basePath, skill.name);
+  return pipe5(
+    Effect5.forEach(
+      skill.files,
+      (file) => writeSkillFile(skillDir, file, agentId),
+      {
+        concurrency: "unbounded"
+      }
+    ),
+    Effect5.map(() => void 0)
+  );
+};
+var writeSkills = (basePath, skills, agentId) => pipe5(
+  Effect5.forEach(
+    skills,
+    (skill) => pipe5(
+      writeSkill(basePath, skill, agentId),
+      Effect5.map(() => ({ success: true, skill: skill.name })),
+      Effect5.catchAll(
+        (error) => Effect5.succeed({
+          success: false,
+          skill: skill.name,
+          error: error.cause instanceof Error ? error.cause.message : String(error.cause)
+        })
+      )
+    ),
+    { concurrency: "unbounded" }
+  ),
+  Effect5.map((results) => ({
+    written: results.filter((r) => r.success).map((r) => r.skill),
+    errors: results.filter(
+      (r) => !r.success
+    ).map((r) => ({ skill: r.skill, error: r.error }))
+  }))
+);
+var writeSkillsAsync = (basePath, skills, agentId) => Effect5.runPromise(writeSkills(basePath, skills, agentId));
+
+// src/lib/tui.ts
+init_esm_shims();
+import process5 from "process";
+import {
+  cancel as clackCancel,
+  confirm as clackConfirm,
+  group as clackGroup,
+  groupMultiselect as clackGroupMultiselect,
+  intro as clackIntro,
+  isCancel as clackIsCancel,
+  log as clackLog,
+  multiselect as clackMultiselect,
+  note as clackNote,
+  outro as clackOutro,
+  password as clackPassword,
+  select as clackSelect,
+  selectKey as clackSelectKey,
+  spinner as clackSpinner,
+  text as clackText
+} from "@clack/prompts";
+var isTTY = Boolean(process5.stdout.isTTY);
+function spinner2() {
+  if (isTTY) {
+    return clackSpinner();
+  }
+  return {
+    start: (message) => {
+      if (message) {
+        process5.stdout.write(`${message}
+`);
+      }
+    },
+    stop: (message) => {
+      if (message) {
+        process5.stdout.write(`${message}
+`);
+      }
+    },
+    message: (message) => {
+      if (message) {
+        process5.stdout.write(`${message}
+`);
+      }
+    }
+  };
+}
+function intro2(message) {
+  if (isTTY) {
+    clackIntro(message);
+  } else {
+    process5.stdout.write(`
+${message}
+`);
+  }
+}
+function outro2(message) {
+  if (isTTY) {
+    clackOutro(message);
+  } else {
+    process5.stdout.write(`${message}
+
+`);
+  }
+}
+var cancel2 = clackCancel;
+var confirm2 = clackConfirm;
+var isCancel2 = clackIsCancel;
+var log2 = clackLog;
+var multiselect = clackMultiselect;
+
+// src/commands/install.ts
+function resolveInstallConfig(options, config) {
+  const orgProjectsFromFlag = options.orgProjects ? options.orgProjects.split(",").map((s) => s.trim()) : void 0;
+  const personalProjectsFromFlag = options.personalProjects ? options.personalProjects.split(",").map((s) => s.trim()) : void 0;
+  return {
+    profile: options.profile ?? config.profile,
+    serverUrl: options.server ?? config.serverUrl,
+    includeUserGlobalRules: options.includeUserGlobals ?? config.includeUserGlobalRules,
+    includeOrgGlobalRules: options.includeOrgGlobals ?? config.includeOrgGlobalRules,
+    orgProjects: orgProjectsFromFlag ?? config.orgProjects,
+    personalProjects: personalProjectsFromFlag ?? config.personalProjects
+  };
+}
+function validateInstallOptions(resolved) {
+  const { profile, orgProjects, personalProjects } = resolved;
+  const hasOrgProjects = orgProjects && orgProjects.length > 0;
+  const hasPersonalProjects = personalProjects && personalProjects.length > 0;
+  if (!(profile || hasOrgProjects || hasPersonalProjects)) {
+    log2.error("No profile or project(s) specified.");
+    log2.info("Either:");
+    log2.info(
+      "  - Add 'profile', 'orgProjects', or 'personalProjects' to braid.json/braid.user.json"
+    );
+    log2.info("  - Use --profile, --org-projects, or --personal-projects flags");
+    log2.info("");
+    log2.info("Examples:");
+    log2.info("  braid-skills install --profile coding-standards");
+    log2.info("  braid-skills install --org-projects proj123,proj456");
+    log2.info("  braid-skills install --personal-projects myproj1");
+    process.exit(1);
+  }
+}
+function buildSourceDescription(resolved) {
+  const { profile, orgProjects, personalProjects } = resolved;
+  if (profile) {
+    return `profile '${profile}'`;
+  }
+  const hasOrgProjects = orgProjects && orgProjects.length > 0;
+  const hasPersonalProjects = personalProjects && personalProjects.length > 0;
+  if (hasOrgProjects || hasPersonalProjects) {
+    const totalProjects = (orgProjects?.length ?? 0) + (personalProjects?.length ?? 0);
+    return totalProjects === 1 ? `project ${orgProjects?.[0] ?? personalProjects?.[0]}` : `${totalProjects} projects`;
+  }
+  return "unknown source";
+}
+function buildFetchOptions(resolved) {
+  const fetchOptions = {
+    serverUrl: resolved.serverUrl,
+    includeUserGlobalRules: resolved.includeUserGlobalRules,
+    includeOrgGlobalRules: resolved.includeOrgGlobalRules
+  };
+  if (resolved.profile) {
+    fetchOptions.profile = resolved.profile;
+  }
+  if (resolved.orgProjects && resolved.orgProjects.length > 0) {
+    fetchOptions.orgProjects = resolved.orgProjects;
+  }
+  if (resolved.personalProjects && resolved.personalProjects.length > 0) {
+    fetchOptions.personalProjects = resolved.personalProjects;
+  }
+  return fetchOptions;
+}
+function displaySkillsAndExit(skills) {
+  log2.info("\nSkills:");
+  for (const skill of skills) {
+    const fileCount = skill.files.length;
+    log2.info(
+      `  ${skill.name} (${fileCount} file${fileCount !== 1 ? "s" : ""})`
+    );
+  }
+  process.exit(0);
+}
+async function resolveAgents(options, installSpinner) {
+  if (options.agents) {
+    const agentIds = options.agents.split(",").map((s) => s.trim());
+    const selectedAgents = agentIds.map((id) => {
+      const agentConfig = getAgentById(id);
+      if (!agentConfig) {
+        log2.warn(`Unknown agent: ${id}`);
+        return null;
+      }
+      return {
+        ...agentConfig,
+        hasProjectConfig: true,
+        hasGlobalConfig: true
+      };
+    }).filter((a) => a !== null);
+    if (selectedAgents.length === 0) {
+      log2.error("No valid agents specified.");
+      process.exit(1);
+    }
+    return selectedAgents;
+  }
+  installSpinner.start("Detecting installed agents...");
+  const detectedAgents = await detectAgentsAsync();
+  installSpinner.stop(`Detected ${detectedAgents.length} agent(s)`);
+  if (detectedAgents.length === 0) {
+    log2.warn("No AI coding agents detected.");
+    log2.info(
+      "Supported agents: claude-code, opencode, cursor, windsurf, cline, and more."
+    );
+    log2.info(
+      "Use --agents to specify agents manually: braid-skills install -p my-profile -a claude-code"
+    );
+    process.exit(1);
+  }
+  return detectedAgents;
+}
+async function selectAgents(detectedAgents, options) {
+  if (options.yes) {
+    return detectedAgents;
+  }
+  const agentChoices = detectedAgents.map((agent) => ({
+    value: agent,
+    label: agent.name,
+    hint: options.global ? agent.globalPath : agent.projectPath
+  }));
+  const selected = await multiselect({
+    message: "Select agents to install to:",
+    options: agentChoices,
+    initialValues: detectedAgents,
+    required: true
+  });
+  if (isCancel2(selected)) {
+    cancel2("Install cancelled.");
+    process.exit(0);
+  }
+  return selected;
+}
+async function installToAgent(agent, response, serverUrl, options, installSpinner) {
+  const installPath = resolveInstallPath(agent, {
+    global: options.global === true
+  });
+  installSpinner.start(`Installing to ${agent.name}...`);
+  const result = await writeSkillsAsync(installPath, response.skills, agent.id);
+  if (result.errors.length > 0) {
+    installSpinner.stop(
+      `${agent.name}: ${result.written.length} installed, ${result.errors.length} failed`
+    );
+    for (const err of result.errors) {
+      log2.warn(`  Failed: ${err.skill} - ${err.error}`);
+    }
+  } else {
+    installSpinner.stop(
+      `${agent.name}: ${result.written.length} skills installed`
+    );
+  }
+  await updateMetadataAsync(
+    installPath,
+    response.skills.map((s) => ({
+      name: s.name,
+      source: response.source,
+      version: response.version,
+      serverUrl
+    }))
+  );
+  return { written: result.written.length, errors: result.errors.length };
+}
+async function installCommand(options) {
+  const config = await loadMergedConfigAsync();
+  const resolved = resolveInstallConfig(options, config);
+  validateInstallOptions(resolved);
+  const sourceDesc = buildSourceDescription(resolved);
+  intro2(`Installing skills from ${sourceDesc}`);
+  const installSpinner = spinner2();
+  installSpinner.start("Fetching skills from Braid...");
+  try {
+    const fetchOptions = buildFetchOptions(resolved);
+    const response = await fetchSkillsAsync(fetchOptions);
+    installSpinner.stop(`Found ${response.skills.length} skills`);
+    if (response.skills.length === 0) {
+      log2.warn(
+        "No skills found. Check that your profile/project has enabled rules."
+      );
+      process.exit(0);
+    }
+    if (options.list) {
+      displaySkillsAndExit(response.skills);
+    }
+    let selectedAgents = await resolveAgents(options, installSpinner);
+    if (!options.agents) {
+      selectedAgents = await selectAgents(selectedAgents, options);
+    }
+    let totalWritten = 0;
+    let totalErrors = 0;
+    for (const agent of selectedAgents) {
+      const result = await installToAgent(
+        agent,
+        response,
+        resolved.serverUrl,
+        options,
+        installSpinner
+      );
+      totalWritten += result.written;
+      totalErrors += result.errors;
+    }
+    if (totalErrors > 0) {
+      outro2(`Installed ${totalWritten} skills with ${totalErrors} errors.`);
+    } else {
+      outro2(
+        `Successfully installed ${totalWritten} skills to ${selectedAgents.length} agent(s).`
+      );
+    }
+    log2.info("Run 'braid-skills list' to see installed skills.");
+  } catch (error) {
+    installSpinner.stop("Install failed");
+    const message = error instanceof Error ? error.message : String(error);
+    log2.error(message);
+    process.exit(1);
+  }
+}
+
+// src/commands/list.ts
+init_esm_shims();
+import { log as log3, spinner as spinner3 } from "@clack/prompts";
+function formatRelativeTime(isoDate) {
+  const date = new Date(isoDate);
+  const now = /* @__PURE__ */ new Date();
+  const diffMs = now.getTime() - date.getTime();
+  const diffMins = Math.floor(diffMs / 6e4);
+  const diffHours = Math.floor(diffMins / 60);
+  const diffDays = Math.floor(diffHours / 24);
+  if (diffMins < 1) {
+    return "just now";
+  }
+  if (diffMins < 60) {
+    return `${diffMins} minute${diffMins !== 1 ? "s" : ""} ago`;
+  }
+  if (diffHours < 24) {
+    return `${diffHours} hour${diffHours !== 1 ? "s" : ""} ago`;
+  }
+  if (diffDays < 30) {
+    return `${diffDays} day${diffDays !== 1 ? "s" : ""} ago`;
+  }
+  return date.toLocaleDateString();
+}
+function displayAgentSkills(agent, installPath, braidSkills) {
+  const nameWidth = 25;
+  const sourceWidth = 20;
+  const installedWidth = 15;
+  log3.info("");
+  log3.info(`Agent: ${agent.name} (${installPath})`);
+  log3.info("\u2500".repeat(60));
+  const header = [
+    "Skill".padEnd(nameWidth),
+    "Source".padEnd(sourceWidth),
+    "Installed".padEnd(installedWidth)
+  ].join(" ");
+  log3.info(header);
+  log3.info("\u2500".repeat(60));
+  for (const skill of braidSkills) {
+    const sourceName = skill.source.name;
+    const row = [
+      skill.name.slice(0, nameWidth).padEnd(nameWidth),
+      sourceName.slice(0, sourceWidth).padEnd(sourceWidth),
+      formatRelativeTime(skill.installedAt).padEnd(installedWidth)
+    ].join(" ");
+    log3.info(row);
+  }
+}
+async function listCommand(options) {
+  const listSpinner = spinner3();
+  listSpinner.start("Scanning for installed skills...");
+  try {
+    const detectedAgents = await detectAgentsAsync();
+    if (detectedAgents.length === 0) {
+      listSpinner.stop("No agents detected");
+      log3.warn("No AI coding agents detected.");
+      return;
+    }
+    listSpinner.stop(`Found ${detectedAgents.length} agent(s)`);
+    let totalSkills = 0;
+    for (const agent of detectedAgents) {
+      const installPath = resolveInstallPath(agent, {
+        global: options.global === true
+      });
+      const exists = await directoryExistsAsync(installPath);
+      if (!exists) {
+        continue;
+      }
+      const metadata = await readMetadataAsync(installPath);
+      const braidSkills = metadata.skills;
+      if (braidSkills.length === 0) {
+        continue;
+      }
+      totalSkills += braidSkills.length;
+      displayAgentSkills(agent, installPath, braidSkills);
+    }
+    if (totalSkills === 0) {
+      log3.warn("\nNo skills installed via braid-skills.");
+      log3.info(
+        "Run 'braid-skills install --profile <name>' to install skills."
+      );
+    } else {
+      log3.info("");
+      log3.info(`Total: ${totalSkills} skill(s) installed`);
+    }
+  } catch (error) {
+    listSpinner.stop("List failed");
+    const message = error instanceof Error ? error.message : String(error);
+    log3.error(message);
+    process.exit(1);
+  }
+}
+
+// src/commands/remove.ts
+init_esm_shims();
+import { rm } from "fs/promises";
+import { join as join5 } from "path";
+import process6 from "process";
+async function collectInstalledSkills(detectedAgents, options) {
+  const skillsToRemove = [];
+  for (const agent of detectedAgents) {
+    const installPath = resolveInstallPath(agent, {
+      global: options.global === true
+    });
+    const exists = await directoryExistsAsync(installPath);
+    if (!exists) {
+      continue;
+    }
+    const metadata = await readMetadataAsync(installPath);
+    for (const skill of metadata.skills) {
+      skillsToRemove.push({
+        name: skill.name,
+        agentName: agent.name,
+        installPath,
+        skillPath: join5(installPath, skill.name)
+      });
+    }
+  }
+  return skillsToRemove;
+}
+async function selectSkillsToRemove(skillsToRemove, options) {
+  if (options.skill) {
+    const selected = skillsToRemove.filter((s) => s.name === options.skill);
+    if (selected.length === 0) {
+      log2.error(`Skill '${options.skill}' not found.`);
+      log2.info("Run 'braid-skills list' to see installed skills.");
+      process6.exit(1);
+    }
+    return selected;
+  }
+  if (options.all || options.yes) {
+    return skillsToRemove;
+  }
+  const choices = skillsToRemove.map((skill) => ({
+    value: skill,
+    label: skill.name,
+    hint: skill.agentName
+  }));
+  const result = await multiselect({
+    message: "Select skills to remove:",
+    options: choices,
+    required: true
+  });
+  if (isCancel2(result)) {
+    cancel2("Remove cancelled.");
+    process6.exit(0);
+  }
+  return result;
+}
+async function confirmRemoval(selectedCount, options) {
+  if (options.yes || options.skill || options.all) {
+    return;
+  }
+  const confirmed = await confirm2({
+    message: `Remove ${selectedCount} skill(s)?`,
+    initialValue: false
+  });
+  if (isCancel2(confirmed) || !confirmed) {
+    cancel2("Remove cancelled.");
+    process6.exit(0);
+  }
+}
+async function removeSkill(skill, removeSpinner) {
+  removeSpinner.start(`Removing ${skill.name} from ${skill.agentName}...`);
+  try {
+    await rm(skill.skillPath, { recursive: true, force: true });
+    await removeFromMetadataAsync(skill.installPath, skill.name);
+    removeSpinner.stop(`Removed ${skill.name} from ${skill.agentName}`);
+    return true;
+  } catch (error) {
+    removeSpinner.stop(`Failed to remove ${skill.name}`);
+    const message = error instanceof Error ? error.message : String(error);
+    log2.warn(`  ${message}`);
+    return false;
+  }
+}
+async function removeCommand(options) {
+  const removeSpinner = spinner2();
+  removeSpinner.start("Scanning for installed skills...");
+  try {
+    const detectedAgents = await detectAgentsAsync();
+    if (detectedAgents.length === 0) {
+      removeSpinner.stop("No agents detected");
+      log2.warn("No AI coding agents detected.");
+      return;
+    }
+    const skillsToRemove = await collectInstalledSkills(
+      detectedAgents,
+      options
+    );
+    removeSpinner.stop(`Found ${skillsToRemove.length} installed skill(s)`);
+    if (skillsToRemove.length === 0) {
+      log2.warn("No skills installed via braid-skills.");
+      return;
+    }
+    const selected = await selectSkillsToRemove(skillsToRemove, options);
+    await confirmRemoval(selected.length, options);
+    let removed = 0;
+    let errors = 0;
+    for (const skill of selected) {
+      const success = await removeSkill(skill, removeSpinner);
+      if (success) {
+        removed++;
+      } else {
+        errors++;
+      }
+    }
+    if (errors > 0) {
+      outro2(`Removed ${removed} skill(s) with ${errors} error(s).`);
+    } else {
+      outro2(`Successfully removed ${removed} skill(s).`);
+    }
+  } catch (error) {
+    removeSpinner.stop("Remove failed");
+    const message = error instanceof Error ? error.message : String(error);
+    log2.error(message);
+    process6.exit(1);
+  }
+}
+
+// src/commands/update.ts
+init_esm_shims();
+import {
+  cancel as cancel3,
+  isCancel as isCancel3,
+  log as log4,
+  multiselect as multiselect2,
+  outro as outro3,
+  spinner as spinner4
+} from "@clack/prompts";
+import { Data as Data5, Effect as Effect6, pipe as pipe6 } from "effect";
+var UpdateError = class extends Data5.TaggedError("UpdateError") {
+};
+var UserCancelledError = class extends Data5.TaggedError("UserCancelledError") {
+};
+var collectSourcesFromAgent = (agent, options, sourcesToUpdate) => Effect6.tryPromise({
+  try: async () => {
+    const installPath = resolveInstallPath(agent, {
+      global: options.global === true
+    });
+    const exists = await directoryExistsAsync(installPath);
+    if (!exists) {
+      return;
+    }
+    const metadata = await readMetadataAsync(installPath);
+    for (const skill of metadata.skills) {
+      const key = skill.source.type === "profile" ? `profile:${skill.source.name}` : `projects:${skill.source.name}`;
+      if (!sourcesToUpdate.has(key)) {
+        sourcesToUpdate.set(key, {
+          type: skill.source.type,
+          name: skill.source.name,
+          orgProjects: skill.source.orgProjects,
+          personalProjects: skill.source.personalProjects,
+          serverUrl: skill.serverUrl,
+          agents: []
+        });
+      }
+      const source = sourcesToUpdate.get(key);
+      if (source && !source.agents.some((a) => a.installPath === installPath)) {
+        source.agents.push({
+          agentId: agent.id,
+          agentName: agent.name,
+          installPath
+        });
+      }
+    }
+  },
+  catch: () => new UpdateError({ message: "Failed to collect sources" })
+});
+var collectSources = (detectedAgents, options) => pipe6(
+  Effect6.succeed(/* @__PURE__ */ new Map()),
+  Effect6.tap(
+    (sourcesToUpdate) => Effect6.forEach(
+      detectedAgents,
+      (agent) => collectSourcesFromAgent(agent, options, sourcesToUpdate),
+      { concurrency: 1 }
+    )
+  )
+);
+var selectSources = (sourcesToUpdate, options) => {
+  if (options.yes) {
+    return Effect6.succeed(sourcesToUpdate);
+  }
+  return Effect6.tryPromise({
+    try: async () => {
+      const sources = Array.from(sourcesToUpdate.entries()).map(
+        ([key, source]) => ({
+          value: key,
+          label: source.name,
+          hint: `${source.agents.length} agent(s)`
+        })
+      );
+      const selected = await multiselect2({
+        message: "Select sources to update:",
+        options: sources,
+        initialValues: sources.map((s) => s.value),
+        required: true
+      });
+      if (isCancel3(selected)) {
+        throw new Error("cancelled");
+      }
+      for (const key of sourcesToUpdate.keys()) {
+        if (!selected.includes(key)) {
+          sourcesToUpdate.delete(key);
+        }
+      }
+      return sourcesToUpdate;
+    },
+    catch: () => new UserCancelledError({ message: "Update cancelled." })
+  });
+};
+var getSourceDesc = (source) => source.name;
+var buildFetchOptionsForSource = (source, options) => {
+  const serverUrl = options.server ?? source.serverUrl;
+  const fetchOptions = { serverUrl };
+  if (source.type === "profile") {
+    fetchOptions.profile = source.name;
+  } else {
+    const orgProjects = source.orgProjects;
+    const personalProjects = source.personalProjects;
+    const hasOrgProjects = orgProjects !== void 0 && orgProjects.length > 0;
+    const hasPersonalProjects = personalProjects !== void 0 && personalProjects.length > 0;
+    if (!(hasOrgProjects || hasPersonalProjects)) {
+      return null;
+    }
+    if (hasOrgProjects) {
+      fetchOptions.orgProjects = orgProjects;
+    }
+    if (hasPersonalProjects) {
+      fetchOptions.personalProjects = personalProjects;
+    }
+  }
+  return fetchOptions;
+};
+var updateAgentSkills = (agentId, agentName, installPath, response, serverUrl, updateSpinner) => Effect6.tryPromise({
+  try: async () => {
+    updateSpinner.start(`Updating ${agentName}...`);
+    const result = await writeSkillsAsync(
+      installPath,
+      response.skills,
+      agentId
+    );
+    if (result.errors.length > 0) {
+      updateSpinner.stop(
+        `${agentName}: ${result.written.length} updated, ${result.errors.length} failed`
+      );
+    } else {
+      updateSpinner.stop(
+        `${agentName}: ${result.written.length} skills updated`
+      );
+    }
+    await updateMetadataAsync(
+      installPath,
+      response.skills.map((s) => ({
+        name: s.name,
+        source: response.source,
+        version: response.version,
+        serverUrl
+      }))
+    );
+    return { updated: result.written.length, errors: result.errors.length };
+  },
+  catch: (e) => new UpdateError({
+    message: e instanceof Error ? e.message : String(e),
+    source: agentName
+  })
+});
+var updateSource = (source, options, updateSpinner) => {
+  const sourceDesc = getSourceDesc(source);
+  const serverUrl = options.server ?? source.serverUrl;
+  const fetchOptions = buildFetchOptionsForSource(source, options);
+  if (fetchOptions === null) {
+    return Effect6.fail(
+      new UpdateError({
+        message: "Skills installed with legacy metadata format. Please reinstall using 'braid-skills install --profile <name>' or 'braid-skills install --projects <names>'.",
+        source: sourceDesc
+      })
+    );
+  }
+  return pipe6(
+    Effect6.tryPromise({
+      try: async () => {
+        updateSpinner.start(`Fetching latest skills from ${sourceDesc}...`);
+        const response = await fetchSkillsAsync(fetchOptions);
+        updateSpinner.stop(
+          `Fetched ${response.skills.length} skills from ${sourceDesc}`
+        );
+        return response;
+      },
+      catch: (e) => new UpdateError({
+        message: e instanceof Error ? e.message : String(e),
+        source: sourceDesc
+      })
+    }),
+    Effect6.flatMap(
+      (response) => pipe6(
+        Effect6.forEach(
+          source.agents,
+          ({ agentId, agentName, installPath }) => updateAgentSkills(
+            agentId,
+            agentName,
+            installPath,
+            response,
+            serverUrl,
+            updateSpinner
+          ),
+          { concurrency: 1 }
+        ),
+        Effect6.map((results) => ({
+          updated: results.reduce((sum, r) => sum + r.updated, 0),
+          errors: results.reduce((sum, r) => sum + r.errors, 0)
+        }))
+      )
+    )
+  );
+};
+var updateAllSources = (sources, options, updateSpinner) => pipe6(
+  Effect6.forEach(
+    Array.from(sources.values()),
+    (source) => pipe6(
+      updateSource(source, options, updateSpinner),
+      Effect6.catchAll((error) => {
+        updateSpinner.stop(
+          `Failed to update from ${getSourceDesc(source)}`
+        );
+        log4.error(`  ${error.message}`);
+        return Effect6.succeed({ updated: 0, errors: 1 });
+      })
+    ),
+    { concurrency: 1 }
+  ),
+  Effect6.map((results) => ({
+    totalUpdated: results.reduce((sum, r) => sum + r.updated, 0),
+    totalErrors: results.reduce((sum, r) => sum + r.errors, 0)
+  }))
+);
+var handleUpdateError = (error, updateSpinner) => {
+  updateSpinner.stop("Update failed");
+  if (error.message === "No AI coding agents detected.") {
+    log4.warn(error.message);
+    return;
+  }
+  if (error.message === "No skills installed via braid-skills.") {
+    log4.warn(error.message);
+    log4.info(
+      "Run 'braid-skills install --profile <name>' to install skills first."
+    );
+    return;
+  }
+  log4.error(error.message);
+  process.exit(1);
+};
+var handleProgramExit = (result, updateSpinner) => {
+  if (result._tag !== "Failure") {
+    return;
+  }
+  const cause = result.cause;
+  if (cause._tag !== "Fail") {
+    return;
+  }
+  const error = cause.error;
+  if (error._tag === "UserCancelledError") {
+    cancel3(error.message);
+    process.exit(0);
+  }
+  if (error._tag === "UpdateError") {
+    handleUpdateError(error, updateSpinner);
+  }
+};
+async function updateCommand(options) {
+  const updateSpinner = spinner4();
+  updateSpinner.start("Scanning for installed skills...");
+  const program2 = pipe6(
+    Effect6.tryPromise({
+      try: () => detectAgentsAsync(),
+      catch: () => new UpdateError({ message: "Failed to detect agents" })
+    }),
+    Effect6.filterOrFail(
+      (agents) => agents.length > 0,
+      () => new UpdateError({ message: "No AI coding agents detected." })
+    ),
+    Effect6.flatMap((detectedAgents) => collectSources(detectedAgents, options)),
+    Effect6.tap((sources) => {
+      updateSpinner.stop(`Found ${sources.size} source(s) to update`);
+    }),
+    Effect6.filterOrFail(
+      (sources) => sources.size > 0,
+      () => new UpdateError({ message: "No skills installed via braid-skills." })
+    ),
+    Effect6.flatMap((sources) => selectSources(sources, options)),
+    Effect6.flatMap(
+      (selectedSources) => updateAllSources(selectedSources, options, updateSpinner)
+    ),
+    Effect6.tap(({ totalUpdated, totalErrors }) => {
+      if (totalErrors > 0) {
+        outro3(`Updated ${totalUpdated} skills with ${totalErrors} errors.`);
+      } else {
+        outro3(`Successfully updated ${totalUpdated} skills.`);
+      }
+    })
+  );
+  const result = await Effect6.runPromiseExit(program2);
+  handleProgramExit(result, updateSpinner);
+}
+
+// src/index.ts
+var program = new Command();
+program.name("braid-skills").description(
+  "Install Braid rules as agent skills to your local development environment"
+).version("0.1.0");
+var auth = program.command("auth").description("Configure API key for Braid authentication");
+auth.command("login", { isDefault: true }).description("Configure API key").option("-s, --server <url>", "Braid server URL (for review apps, local dev)").action(authCommand);
+auth.command("status").description("Show current authentication status").action(authStatusCommand);
+auth.command("logout").description("Remove stored API key").action(authLogoutCommand);
+program.command("install").alias("add").description("Install skills from a profile or project").option("-p, --profile <name>", "Profile name to install from").option(
+  "--org-projects <ids>",
+  "Comma-separated organization project IDs to install from"
+).option(
+  "--personal-projects <ids>",
+  "Comma-separated personal project IDs to install from"
+).option(
+  "--include-user-globals",
+  "Include user's personal global rules (default: true)"
+).option("--no-include-user-globals", "Exclude user's personal global rules").option(
+  "--include-org-globals",
+  "Include organization's global rules (default: true)"
+).option("--no-include-org-globals", "Exclude organization's global rules").option(
+  "-a, --agents <list>",
+  "Comma-separated list of agents (e.g., claude-code,opencode)"
+).option("-g, --global", "Install to global agent directories").option("-y, --yes", "Skip confirmation prompts").option("-l, --list", "Preview skills without installing").option("-s, --server <url>", "Braid server URL (for review apps, local dev)").action(installCommand);
+program.command("list").alias("ls").description("List installed skills").option("-g, --global", "List skills in global directories only").action(listCommand);
+program.command("update").alias("up").description("Update installed skills to the latest version").option("-g, --global", "Update skills in global directories only").option("-y, --yes", "Skip confirmation prompts").option("-s, --server <url>", "Braid server URL (for review apps, local dev)").action(updateCommand);
+program.command("remove").alias("rm").description("Remove installed skills").option("-a, --all", "Remove all installed skills").option("-g, --global", "Remove skills from global directories only").option("-y, --yes", "Skip confirmation prompts").option("--skill <name>", "Remove a specific skill by name").action(removeCommand);
+program.parse();
+//# sourceMappingURL=index.js.map