@orderful/droid 0.15.0 → 0.16.1

package/dist/index.js

@@ -1,6 +1,952 @@
-// Re-export types and utilities for potential programmatic usage
-export * from './lib/types.js';
-export * from './lib/config.js';
-export * from './lib/skills.js';
-export * from './lib/version.js';
-//# sourceMappingURL=index.js.map
+// src/lib/types.ts
+var Platform = /* @__PURE__ */ ((Platform3) => {
+  Platform3["ClaudeCode"] = "claude-code";
+  Platform3["OpenCode"] = "opencode";
+  return Platform3;
+})(Platform || {});
+var AIToolValue = Platform;
+function getAITag() {
+  return "@droid";
+}
+var BuiltInOutput = /* @__PURE__ */ ((BuiltInOutput2) => {
+  BuiltInOutput2["Terminal"] = "terminal";
+  BuiltInOutput2["Editor"] = "editor";
+  return BuiltInOutput2;
+})(BuiltInOutput || {});
+var SkillStatus = /* @__PURE__ */ ((SkillStatus2) => {
+  SkillStatus2["Stable"] = "stable";
+  SkillStatus2["Beta"] = "beta";
+  SkillStatus2["Alpha"] = "alpha";
+  return SkillStatus2;
+})(SkillStatus || {});
+var ConfigOptionType = /* @__PURE__ */ ((ConfigOptionType2) => {
+  ConfigOptionType2["String"] = "string";
+  ConfigOptionType2["Boolean"] = "boolean";
+  ConfigOptionType2["Select"] = "select";
+  return ConfigOptionType2;
+})(ConfigOptionType || {});
+function getPlatformTools(config) {
+  return config.platforms[config.platform]?.tools ?? {};
+}
+function setPlatformTools(config, tools) {
+  if (!config.platforms[config.platform]) {
+    config.platforms[config.platform] = { tools: {} };
+  }
+  config.platforms[config.platform].tools = tools;
+}
+
+// src/lib/config.ts
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
+import { homedir } from "os";
+import { join } from "path";
+import YAML from "yaml";
+var CONFIG_DIR = join(homedir(), ".droid");
+var CONFIG_FILE = join(CONFIG_DIR, "config.yaml");
+var DEFAULT_AUTO_UPDATE = {
+  app: false,
+  // Opt-in: user must enable
+  tools: true
+  // Opt-out: enabled by default (tools only update when app updates)
+};
+var DEFAULT_CONFIG = {
+  platform: "claude-code" /* ClaudeCode */,
+  user_mention: "@user",
+  output_preference: "terminal" /* Terminal */,
+  git_username: "",
+  platforms: {}
+};
+function migrateConfig(config) {
+  if ("ai_tool" in config && !("platform" in config)) {
+    const legacyConfig = config;
+    return {
+      platform: legacyConfig.ai_tool,
+      user_mention: legacyConfig.user_mention ?? DEFAULT_CONFIG.user_mention,
+      output_preference: legacyConfig.output_preference ?? DEFAULT_CONFIG.output_preference,
+      git_username: legacyConfig.git_username ?? DEFAULT_CONFIG.git_username,
+      platforms: {
+        [legacyConfig.ai_tool]: {
+          tools: legacyConfig.skills ?? {}
+        }
+      }
+    };
+  }
+  return {
+    ...DEFAULT_CONFIG,
+    ...config,
+    platforms: config.platforms ?? {}
+  };
+}
+function ensureConfigDir() {
+  if (!existsSync(CONFIG_DIR)) {
+    mkdirSync(CONFIG_DIR, { recursive: true });
+  }
+}
+function configExists() {
+  return existsSync(CONFIG_FILE);
+}
+function loadConfig() {
+  ensureConfigDir();
+  if (!existsSync(CONFIG_FILE)) {
+    return { ...DEFAULT_CONFIG };
+  }
+  try {
+    const content = readFileSync(CONFIG_FILE, "utf-8");
+    const rawConfig = YAML.parse(content);
+    const needsMigration = "ai_tool" in rawConfig && !("platform" in rawConfig);
+    const config = migrateConfig(rawConfig);
+    if (needsMigration) {
+      saveConfig(config);
+    }
+    return config;
+  } catch (error) {
+    const message = error instanceof Error ? error.message : "Unknown error";
+    console.error(`Error reading config: ${message}`);
+    return { ...DEFAULT_CONFIG };
+  }
+}
+function saveConfig(config) {
+  ensureConfigDir();
+  const content = YAML.stringify(config, { indent: 2 });
+  writeFileSync(CONFIG_FILE, content, "utf-8");
+}
+function getConfigValue(key) {
+  const config = loadConfig();
+  const keys = key.split(".");
+  let value = config;
+  for (const k of keys) {
+    if (value === void 0 || value === null || typeof value !== "object") {
+      return void 0;
+    }
+    value = value[k];
+  }
+  return value;
+}
+function setConfigValue(key, value) {
+  const config = loadConfig();
+  const keys = key.split(".");
+  let current = config;
+  for (let i = 0; i < keys.length - 1; i++) {
+    if (current[keys[i]] === void 0) {
+      current[keys[i]] = {};
+    }
+    current = current[keys[i]];
+  }
+  current[keys[keys.length - 1]] = value;
+  saveConfig(config);
+}
+function getConfigPath() {
+  return CONFIG_FILE;
+}
+function getConfigDir() {
+  return CONFIG_DIR;
+}
+function getSkillOverridesPath(skillName) {
+  return join(CONFIG_DIR, "skills", skillName, "overrides.yaml");
+}
+function loadSkillOverrides(skillName) {
+  const overridesPath = getSkillOverridesPath(skillName);
+  if (!existsSync(overridesPath)) {
+    return {};
+  }
+  try {
+    const content = readFileSync(overridesPath, "utf-8");
+    return YAML.parse(content) || {};
+  } catch {
+    return {};
+  }
+}
+function saveSkillOverrides(skillName, overrides) {
+  const overridesPath = getSkillOverridesPath(skillName);
+  const skillDir = join(CONFIG_DIR, "skills", skillName);
+  if (!existsSync(skillDir)) {
+    mkdirSync(skillDir, { recursive: true });
+  }
+  const content = YAML.stringify(overrides, { indent: 2 });
+  writeFileSync(overridesPath, content, "utf-8");
+}
+function getAutoUpdateConfig() {
+  const config = loadConfig();
+  return {
+    ...DEFAULT_AUTO_UPDATE,
+    ...config.auto_update
+  };
+}
+function setAutoUpdateConfig(updates) {
+  const config = loadConfig();
+  config.auto_update = {
+    ...DEFAULT_AUTO_UPDATE,
+    ...config.auto_update,
+    ...updates
+  };
+  saveConfig(config);
+}
+
+// src/lib/skills.ts
+import { existsSync as existsSync4, readdirSync as readdirSync3, readFileSync as readFileSync5, mkdirSync as mkdirSync3, writeFileSync as writeFileSync3, rmSync } from "fs";
+import { join as join6, dirname as dirname4 } from "path";
+import { fileURLToPath as fileURLToPath4 } from "url";
+import YAML4 from "yaml";
+
+// src/lib/agents.ts
+import { existsSync as existsSync3, readdirSync as readdirSync2, readFileSync as readFileSync4, writeFileSync as writeFileSync2, unlinkSync, mkdirSync as mkdirSync2 } from "fs";
+import { join as join5, dirname as dirname3 } from "path";
+import { fileURLToPath as fileURLToPath3 } from "url";
+import YAML3 from "yaml";
+
+// src/lib/platforms.ts
+import { join as join2 } from "path";
+import { homedir as homedir2 } from "os";
+var PLATFORM_PATHS = {
+  ["claude-code" /* ClaudeCode */]: {
+    skills: join2(homedir2(), ".claude", "skills"),
+    commands: join2(homedir2(), ".claude", "commands"),
+    agents: join2(homedir2(), ".claude", "agents"),
+    config: join2(homedir2(), ".claude", "CLAUDE.md")
+  },
+  ["opencode" /* OpenCode */]: {
+    skills: join2(homedir2(), ".config", "opencode", "skills"),
+    commands: join2(homedir2(), ".config", "opencode", "command"),
+    agents: join2(homedir2(), ".config", "opencode", "agent"),
+    config: join2(homedir2(), ".config", "opencode", "AGENTS.md")
+  }
+};
+function getSkillsPath(platform) {
+  return PLATFORM_PATHS[platform].skills;
+}
+function getCommandsPath(platform) {
+  return PLATFORM_PATHS[platform].commands;
+}
+function getAgentsPath(platform) {
+  return PLATFORM_PATHS[platform].agents;
+}
+function getConfigPath2(platform) {
+  return PLATFORM_PATHS[platform].config;
+}
+
+// src/lib/tools.ts
+import { existsSync as existsSync2, readdirSync, readFileSync as readFileSync3 } from "fs";
+import { join as join4, dirname as dirname2 } from "path";
+import { fileURLToPath as fileURLToPath2 } from "url";
+import YAML2 from "yaml";
+
+// src/lib/version.ts
+import { readFileSync as readFileSync2 } from "fs";
+import { fileURLToPath } from "url";
+import { dirname, join as join3 } from "path";
+import { execSync } from "child_process";
+import chalk from "chalk";
+var __dirname = dirname(fileURLToPath(import.meta.url));
+var packageJsonPath = join3(__dirname, "../../package.json");
+function getVersion() {
+  try {
+    const pkg = JSON.parse(readFileSync2(packageJsonPath, "utf-8"));
+    return pkg.version;
+  } catch {
+    return "0.0.0";
+  }
+}
+function compareSemver(a, b) {
+  const partsA = a.split(".").map(Number);
+  const partsB = b.split(".").map(Number);
+  for (let i = 0; i < 3; i++) {
+    const numA = partsA[i] || 0;
+    const numB = partsB[i] || 0;
+    if (numA > numB) return 1;
+    if (numA < numB) return -1;
+  }
+  return 0;
+}
+function getUpdateInfo() {
+  const currentVersion = getVersion();
+  try {
+    const latestVersion = execSync("npm view @orderful/droid version 2>/dev/null", {
+      encoding: "utf-8",
+      timeout: 3e3
+    }).trim();
+    return {
+      hasUpdate: latestVersion ? compareSemver(latestVersion, currentVersion) > 0 : false,
+      currentVersion,
+      latestVersion: latestVersion || null
+    };
+  } catch {
+    return {
+      hasUpdate: false,
+      currentVersion,
+      latestVersion: null
+    };
+  }
+}
+function runUpdate() {
+  try {
+    execSync("npm install -g @orderful/droid@latest", {
+      encoding: "utf-8",
+      stdio: "pipe",
+      timeout: 6e4
+    });
+    return { success: true, message: "Update complete!" };
+  } catch (error) {
+    return { success: false, message: `Update failed: ${error}` };
+  }
+}
+async function checkForUpdates() {
+  try {
+    const currentVersion = getVersion();
+    const latestVersion = execSync("npm view @orderful/droid version 2>/dev/null", {
+      encoding: "utf-8",
+      timeout: 3e3
+    }).trim();
+    if (latestVersion && compareSemver(latestVersion, currentVersion) > 0) {
+      console.log(
+        chalk.yellow(
+          `
+\u26A0\uFE0F  A new version of droid is available (${currentVersion} \u2192 ${latestVersion})`
+        )
+      );
+      console.log(chalk.yellow(`   Run ${chalk.bold("droid update")} to upgrade
+`));
+    }
+  } catch {
+  }
+}
+
+// src/lib/tools.ts
+var __dirname2 = dirname2(fileURLToPath2(import.meta.url));
+var BUNDLED_TOOLS_DIR = join4(__dirname2, "../tools");
+function loadToolManifest(toolDir) {
+  const manifestPath = join4(toolDir, "TOOL.yaml");
+  if (!existsSync2(manifestPath)) {
+    return null;
+  }
+  try {
+    const content = readFileSync3(manifestPath, "utf-8");
+    const parsed = YAML2.parse(content);
+    const includes = {
+      skills: parsed.includes?.skills || [],
+      commands: parsed.includes?.commands || [],
+      agents: parsed.includes?.agents || []
+    };
+    return {
+      ...parsed,
+      includes
+    };
+  } catch {
+    return null;
+  }
+}
+
+// src/lib/agents.ts
+var __dirname3 = dirname3(fileURLToPath3(import.meta.url));
+var BUNDLED_TOOLS_DIR2 = join5(__dirname3, "../tools");
+function getAgentsInstallPath(platform) {
+  return getAgentsPath(platform);
+}
+function parseAgentFrontmatter(content) {
+  const trimmed = content.trimStart();
+  if (!trimmed.startsWith("---")) {
+    return null;
+  }
+  const endMatch = trimmed.slice(3).indexOf("---");
+  if (endMatch === -1) {
+    return null;
+  }
+  const frontmatterContent = trimmed.slice(3, 3 + endMatch);
+  try {
+    return YAML3.parse(frontmatterContent);
+  } catch {
+    return null;
+  }
+}
+function loadAgentManifest(agentPath) {
+  if (!existsSync3(agentPath)) {
+    return null;
+  }
+  const content = readFileSync4(agentPath, "utf-8");
+  const frontmatter = parseAgentFrontmatter(content);
+  if (!frontmatter || !frontmatter.name) {
+    return null;
+  }
+  const toolDir = dirname3(dirname3(agentPath));
+  const toolManifest = loadToolManifest(toolDir);
+  return {
+    name: frontmatter.name,
+    description: frontmatter.description || "",
+    version: toolManifest?.version || "0.0.0",
+    status: toolManifest?.status,
+    mode: frontmatter.mode,
+    model: frontmatter.model,
+    color: frontmatter.color,
+    tools: frontmatter.tools
+  };
+}
+function getInstalledAgentsDir() {
+  const config = loadConfig();
+  return getAgentsInstallPath(config.platform);
+}
+function isAgentInstalled(agentName) {
+  const config = loadConfig();
+  const agentsDir = getAgentsInstallPath(config.platform);
+  const agentPath = join5(agentsDir, `${agentName}.md`);
+  return existsSync3(agentPath);
+}
+function generateClaudeCodeAgent(manifest, agentContent) {
+  const lines = [
+    "---",
+    `name: ${manifest.name}`,
+    `description: ${manifest.description}`
+  ];
+  if (manifest.tools && manifest.tools.length > 0) {
+    lines.push(`tools: ${manifest.tools.join(", ")}`);
+  }
+  if (manifest.color) {
+    lines.push(`color: ${manifest.color}`);
+  }
+  lines.push("---", "", agentContent.trim(), "");
+  return lines.join("\n");
+}
+function generateOpenCodeAgent(manifest, agentContent) {
+  const lines = [
+    "---",
+    `description: ${manifest.description}`,
+    `mode: ${manifest.mode || "subagent"}`
+  ];
+  if (manifest.tools && manifest.tools.length > 0) {
+    lines.push("tools:");
+    for (const tool of manifest.tools) {
+      const toolName = tool.toLowerCase();
+      lines.push(`  ${toolName}: true`);
+    }
+  }
+  lines.push("---", "", agentContent.trim(), "");
+  return lines.join("\n");
+}
+function installAgentFromPath(agentPath, agentName) {
+  const config = loadConfig();
+  const manifest = loadAgentManifest(agentPath);
+  if (!manifest) {
+    return { success: false, message: `Agent manifest not found: ${agentName}` };
+  }
+  try {
+    const rawContent = readFileSync4(agentPath, "utf-8");
+    const frontmatterMatch = rawContent.match(/^---\n[\s\S]*?\n---\n?/);
+    const agentContent = frontmatterMatch ? rawContent.slice(frontmatterMatch[0].length) : rawContent;
+    const installedContent = config.platform === "claude-code" /* ClaudeCode */ ? generateClaudeCodeAgent(manifest, agentContent) : generateOpenCodeAgent(manifest, agentContent);
+    const agentsDir = getAgentsInstallPath(config.platform);
+    if (!existsSync3(agentsDir)) {
+      mkdirSync2(agentsDir, { recursive: true });
+    }
+    const outputPath = join5(agentsDir, `${agentName}.md`);
+    writeFileSync2(outputPath, installedContent);
+    const targetDir = config.platform === "claude-code" /* ClaudeCode */ ? "~/.claude/agents/" : "~/.config/opencode/agent/";
+    return { success: true, message: `Installed ${agentName} to ${targetDir}` };
+  } catch (error) {
+    return { success: false, message: `Failed to install agent: ${error}` };
+  }
+}
+function uninstallAgent(agentName) {
+  const config = loadConfig();
+  const agentsDir = getAgentsInstallPath(config.platform);
+  const agentPath = join5(agentsDir, `${agentName}.md`);
+  if (!existsSync3(agentPath)) {
+    return { success: false, message: `Agent not installed: ${agentName}` };
+  }
+  try {
+    unlinkSync(agentPath);
+    return { success: true, message: `Uninstalled ${agentName}` };
+  } catch (error) {
+    return { success: false, message: `Failed to uninstall agent: ${error}` };
+  }
+}
+
+// src/lib/skills.ts
+var DROID_SKILLS_START = "<!-- droid-skills-start -->";
+var DROID_SKILLS_END = "<!-- droid-skills-end -->";
+var __dirname4 = dirname4(fileURLToPath4(import.meta.url));
+var BUNDLED_SKILLS_DIR = join6(__dirname4, "../tools");
+function getBundledSkillsDir() {
+  return BUNDLED_SKILLS_DIR;
+}
+function getSkillsInstallPath(platform) {
+  return getSkillsPath(platform);
+}
+function getCommandsInstallPath(platform) {
+  return getCommandsPath(platform);
+}
+function getPlatformConfigPath(platform) {
+  return getConfigPath2(platform);
+}
+function updatePlatformConfigSkills(platform, installedSkills) {
+  const configPath = getPlatformConfigPath(platform);
+  let content = "";
+  if (existsSync4(configPath)) {
+    content = readFileSync5(configPath, "utf-8");
+  }
+  const skillLines = installedSkills.map((name) => {
+    const relativePath = `skills/${name}/SKILL.md`;
+    return `- [${name}](${relativePath})`;
+  });
+  const skillsSection = installedSkills.length > 0 ? `${DROID_SKILLS_START}
+## Droid Skills
+
+${skillLines.join("\n")}
+${DROID_SKILLS_END}` : "";
+  const startIdx = content.indexOf(DROID_SKILLS_START);
+  const endIdx = content.indexOf(DROID_SKILLS_END);
+  if (startIdx !== -1 && endIdx !== -1) {
+    content = content.slice(0, startIdx) + skillsSection + content.slice(endIdx + DROID_SKILLS_END.length);
+  } else if (skillsSection) {
+    content = content.trim() + "\n\n" + skillsSection + "\n";
+  }
+  const configDir = dirname4(configPath);
+  if (!existsSync4(configDir)) {
+    mkdirSync3(configDir, { recursive: true });
+  }
+  writeFileSync3(configPath, content, "utf-8");
+}
+function parseSkillFrontmatter(content) {
+  const trimmed = content.trimStart();
+  if (!trimmed.startsWith("---")) {
+    return null;
+  }
+  const endMatch = trimmed.slice(3).indexOf("---");
+  if (endMatch === -1) {
+    return null;
+  }
+  const frontmatterContent = trimmed.slice(3, 3 + endMatch);
+  try {
+    return YAML4.parse(frontmatterContent);
+  } catch {
+    return null;
+  }
+}
+function loadSkillManifest(skillDir) {
+  const skillMdPath = join6(skillDir, "SKILL.md");
+  if (!existsSync4(skillMdPath)) {
+    return null;
+  }
+  const content = readFileSync5(skillMdPath, "utf-8");
+  const frontmatter = parseSkillFrontmatter(content);
+  if (!frontmatter || !frontmatter.name) {
+    return null;
+  }
+  const toolDir = dirname4(dirname4(skillDir));
+  const toolManifest = loadToolManifest(toolDir);
+  return {
+    name: frontmatter.name,
+    description: frontmatter.description || "",
+    version: toolManifest?.version || "0.0.0",
+    status: toolManifest?.status,
+    dependencies: toolManifest?.dependencies,
+    config_schema: toolManifest?.config_schema
+  };
+}
+function findSkillPath(skillName) {
+  if (!existsSync4(BUNDLED_SKILLS_DIR)) {
+    return null;
+  }
+  const toolDirs = readdirSync3(BUNDLED_SKILLS_DIR, { withFileTypes: true }).filter((dirent) => dirent.isDirectory()).map((dirent) => dirent.name);
+  for (const toolName of toolDirs) {
+    const skillsDir = join6(BUNDLED_SKILLS_DIR, toolName, "skills");
+    if (!existsSync4(skillsDir)) continue;
+    const skillDir = join6(skillsDir, skillName);
+    if (existsSync4(skillDir) && existsSync4(join6(skillDir, "SKILL.md"))) {
+      return {
+        toolDir: join6(BUNDLED_SKILLS_DIR, toolName),
+        skillDir
+      };
+    }
+  }
+  return null;
+}
+function getBundledSkills() {
+  if (!existsSync4(BUNDLED_SKILLS_DIR)) {
+    return [];
+  }
+  const toolDirs = readdirSync3(BUNDLED_SKILLS_DIR, { withFileTypes: true }).filter((dirent) => dirent.isDirectory()).map((dirent) => dirent.name);
+  const skills = [];
+  for (const toolName of toolDirs) {
+    const skillsDir = join6(BUNDLED_SKILLS_DIR, toolName, "skills");
+    if (!existsSync4(skillsDir)) continue;
+    const skillSubdirs = readdirSync3(skillsDir, { withFileTypes: true }).filter((dirent) => dirent.isDirectory()).map((dirent) => dirent.name);
+    for (const skillName of skillSubdirs) {
+      const manifest = loadSkillManifest(join6(skillsDir, skillName));
+      if (manifest) {
+        skills.push(manifest);
+      }
+    }
+  }
+  return skills;
+}
+function isSkillInstalled(skillName) {
+  const config = loadConfig();
+  const tools = getPlatformTools(config);
+  return skillName in tools;
+}
+function getInstalledSkill(skillName) {
+  const config = loadConfig();
+  const tools = getPlatformTools(config);
+  return tools[skillName] || null;
+}
+function getSkillUpdateStatus(skillName) {
+  const installed = getInstalledSkill(skillName);
+  const skillPath = findSkillPath(skillName);
+  const manifest = skillPath ? loadSkillManifest(skillPath.skillDir) : null;
+  if (!installed || !manifest) {
+    return {
+      hasUpdate: false,
+      installedVersion: installed?.version || null,
+      bundledVersion: manifest?.version || null
+    };
+  }
+  return {
+    hasUpdate: manifest.version !== installed.version,
+    installedVersion: installed.version,
+    bundledVersion: manifest.version
+  };
+}
+function getSkillsWithUpdates() {
+  const config = loadConfig();
+  const tools = getPlatformTools(config);
+  const updates = [];
+  for (const skillName of Object.keys(tools)) {
+    const status = getSkillUpdateStatus(skillName);
+    if (status.hasUpdate && status.installedVersion && status.bundledVersion) {
+      updates.push({
+        name: skillName,
+        installedVersion: status.installedVersion,
+        bundledVersion: status.bundledVersion
+      });
+    }
+  }
+  return updates;
+}
+function updateSkill(skillName) {
+  const status = getSkillUpdateStatus(skillName);
+  if (!status.installedVersion) {
+    return { success: false, message: `Skill '${skillName}' is not installed` };
+  }
+  if (!status.bundledVersion) {
+    return { success: false, message: `Skill '${skillName}' not found in bundled skills` };
+  }
+  if (!status.hasUpdate) {
+    return { success: false, message: `Skill '${skillName}' is already at latest version (${status.installedVersion})` };
+  }
+  const result = installSkill(skillName);
+  if (result.success) {
+    return {
+      success: true,
+      message: `Updated ${skillName} from ${status.installedVersion} to ${status.bundledVersion}`
+    };
+  }
+  return result;
+}
+function updateAllSkills() {
+  const config = loadConfig();
+  const tools = getPlatformTools(config);
+  const result = {
+    updated: [],
+    failed: [],
+    upToDate: 0
+  };
+  for (const skillName of Object.keys(tools)) {
+    const status = getSkillUpdateStatus(skillName);
+    if (!status.hasUpdate) {
+      result.upToDate++;
+      continue;
+    }
+    const updateResult = updateSkill(skillName);
+    if (updateResult.success) {
+      result.updated.push({
+        name: skillName,
+        from: status.installedVersion,
+        to: status.bundledVersion
+      });
+    } else {
+      result.failed.push({
+        name: skillName,
+        error: updateResult.message
+      });
+    }
+  }
+  return result;
+}
+function installSkill(skillName) {
+  const config = loadConfig();
+  const skillPath = findSkillPath(skillName);
+  if (!skillPath) {
+    return { success: false, message: `Skill '${skillName}' not found` };
+  }
+  const { toolDir, skillDir } = skillPath;
+  const manifest = loadSkillManifest(skillDir);
+  if (!manifest) {
+    return { success: false, message: `Invalid skill manifest for '${skillName}'` };
+  }
+  if (manifest.dependencies) {
+    for (const dep of manifest.dependencies) {
+      if (!isSkillInstalled(dep)) {
+        return {
+          success: false,
+          message: `Missing dependency: '${dep}'. Install it first with \`droid install ${dep}\``
+        };
+      }
+    }
+  }
+  const skillsPath = getSkillsInstallPath(config.platform);
+  const targetSkillDir = join6(skillsPath, skillName);
+  const commandsPath = getCommandsInstallPath(config.platform);
+  const tools = getPlatformTools(config);
+  const commandsSource = join6(toolDir, "commands");
+  const agentsSource = join6(toolDir, "agents");
+  if (!tools[skillName]) {
+    if (existsSync4(commandsSource)) {
+      const commandFiles = readdirSync3(commandsSource).filter((f) => f.endsWith(".md") && f.toLowerCase() !== "readme.md");
+      for (const file of commandFiles) {
+        const targetCommandPath = join6(commandsPath, file);
+        if (existsSync4(targetCommandPath)) {
+          const commandName = file.replace(".md", "");
+          return {
+            success: false,
+            message: `Cannot install: command /${commandName} already exists at ${targetCommandPath}`
+          };
+        }
+      }
+    }
+    if (existsSync4(agentsSource)) {
+      const agentDirs = readdirSync3(agentsSource, { withFileTypes: true }).filter((dirent) => dirent.isDirectory()).map((dirent) => dirent.name);
+      for (const agentName of agentDirs) {
+        if (isAgentInstalled(agentName)) {
+          return {
+            success: false,
+            message: `Cannot install: agent '${agentName}' already exists at ${getInstalledAgentsDir()}`
+          };
+        }
+      }
+    }
+  }
+  if (!existsSync4(skillsPath)) {
+    mkdirSync3(skillsPath, { recursive: true });
+  }
+  const skillMdSource = join6(skillDir, "SKILL.md");
+  if (existsSync4(skillMdSource)) {
+    if (!existsSync4(targetSkillDir)) {
+      mkdirSync3(targetSkillDir, { recursive: true });
+    }
+    const skillMdTarget = join6(targetSkillDir, "SKILL.md");
+    const content = readFileSync5(skillMdSource, "utf-8");
+    writeFileSync3(skillMdTarget, content);
+  }
+  const referencesSource = join6(skillDir, "references");
+  if (existsSync4(referencesSource)) {
+    const targetReferencesDir = join6(targetSkillDir, "references");
+    if (!existsSync4(targetReferencesDir)) {
+      mkdirSync3(targetReferencesDir, { recursive: true });
+    }
+    const referenceFiles = readdirSync3(referencesSource).filter((f) => f.endsWith(".md"));
+    for (const file of referenceFiles) {
+      const sourcePath = join6(referencesSource, file);
+      const targetPath = join6(targetReferencesDir, file);
+      const content = readFileSync5(sourcePath, "utf-8");
+      writeFileSync3(targetPath, content);
+    }
+  }
+  if (existsSync4(commandsSource)) {
+    if (!existsSync4(commandsPath)) {
+      mkdirSync3(commandsPath, { recursive: true });
+    }
+    const commandFiles = readdirSync3(commandsSource).filter((f) => f.endsWith(".md") && f.toLowerCase() !== "readme.md");
+    for (const file of commandFiles) {
+      const sourcePath = join6(commandsSource, file);
+      const targetPath = join6(commandsPath, file);
+      const content = readFileSync5(sourcePath, "utf-8");
+      writeFileSync3(targetPath, content);
+    }
+  }
+  const installedAgents = [];
+  if (existsSync4(agentsSource)) {
+    const agentDirs = readdirSync3(agentsSource, { withFileTypes: true }).filter((dirent) => dirent.isDirectory()).map((dirent) => dirent.name);
+    for (const agentName of agentDirs) {
+      const agentDir = join6(agentsSource, agentName);
+      const result = installAgentFromPath(agentDir, agentName);
+      if (result.success) {
+        installedAgents.push(agentName);
+      }
+    }
+  }
+  const updatedTools = {
+    ...tools,
+    [skillName]: {
+      version: manifest.version,
+      installed_at: (/* @__PURE__ */ new Date()).toISOString(),
+      ...installedAgents.length > 0 && { bundled_agents: installedAgents }
+    }
+  };
+  setPlatformTools(config, updatedTools);
+  saveConfig(config);
+  const installedSkillNames = Object.keys(updatedTools);
+  updatePlatformConfigSkills(config.platform, installedSkillNames);
+  return { success: true, message: `Installed ${skillName} v${manifest.version}` };
+}
+function uninstallSkill(skillName) {
+  const config = loadConfig();
+  const tools = getPlatformTools(config);
+  if (!isSkillInstalled(skillName)) {
+    return { success: false, message: `Skill '${skillName}' is not installed` };
+  }
+  const skillsPath = getSkillsInstallPath(config.platform);
+  const skillDir = join6(skillsPath, skillName);
+  if (existsSync4(skillDir)) {
+    rmSync(skillDir, { recursive: true });
+  }
+  const skillPath = findSkillPath(skillName);
+  const commandsPath = getCommandsInstallPath(config.platform);
+  const commandsSource = skillPath ? join6(skillPath.toolDir, "commands") : null;
+  if (commandsSource && existsSync4(commandsSource)) {
+    const commandFiles = readdirSync3(commandsSource).filter((f) => f.endsWith(".md") && f.toLowerCase() !== "readme.md");
+    for (const file of commandFiles) {
+      const commandPath = join6(commandsPath, file);
+      if (existsSync4(commandPath)) {
+        rmSync(commandPath);
+      }
+    }
+  }
+  const installedSkillInfo = tools[skillName];
+  if (installedSkillInfo?.bundled_agents) {
+    for (const agentName of installedSkillInfo.bundled_agents) {
+      uninstallAgent(agentName);
+    }
+  }
+  const { [skillName]: removed, ...remainingTools } = tools;
+  setPlatformTools(config, remainingTools);
+  saveConfig(config);
+  const installedSkillNames = Object.keys(remainingTools);
+  updatePlatformConfigSkills(config.platform, installedSkillNames);
+  return { success: true, message: `Uninstalled ${skillName}` };
+}
+function getSkillStatusDisplay(status) {
+  switch (status) {
+    case "alpha" /* Alpha */:
+      return "[alpha]";
+    case "beta" /* Beta */:
+      return "[beta]";
+    case "stable" /* Stable */:
+    default:
+      return "";
+  }
+}
+function isCommandInstalled(commandName, skillName) {
+  if (isSkillInstalled(skillName)) {
+    return true;
+  }
+  const config = loadConfig();
+  const commandsPath = getCommandsInstallPath(config.platform);
+  const cmdPart = commandName.startsWith(skillName + " ") ? commandName.slice(skillName.length + 1) : commandName;
+  const filename = cmdPart.replace(/\s+/g, "-") + ".md";
+  return existsSync4(join6(commandsPath, filename));
+}
+function installCommand(commandName, skillName) {
+  const config = loadConfig();
+  const skillPath = findSkillPath(skillName);
+  if (!skillPath) {
+    return { success: false, message: `Skill '${skillName}' not found` };
+  }
+  const commandsDir = join6(skillPath.toolDir, "commands");
+  if (!existsSync4(commandsDir)) {
+    return { success: false, message: `No commands found for skill '${skillName}'` };
+  }
+  const cmdPart = commandName.startsWith(skillName + " ") ? commandName.slice(skillName.length + 1) : commandName;
+  const files = readdirSync3(commandsDir).filter((f) => f.endsWith(".md") && f.toLowerCase() !== "readme.md");
+  const sourceFile = files.find((f) => {
+    const base = f.replace(".md", "");
+    return base === cmdPart || base === cmdPart.replace(/\s+/g, "-");
+  });
+  if (!sourceFile) {
+    return { success: false, message: `Command file not found for: ${commandName}` };
+  }
+  const commandsPath = getCommandsInstallPath(config.platform);
+  if (!existsSync4(commandsPath)) {
+    mkdirSync3(commandsPath, { recursive: true });
+  }
+  const actualSourcePath = join6(commandsDir, sourceFile);
+  const targetPath = join6(commandsPath, sourceFile);
+  try {
+    const content = readFileSync5(actualSourcePath, "utf-8");
+    writeFileSync3(targetPath, content);
+    return { success: true, message: `Installed /${commandName}` };
+  } catch (error) {
+    return { success: false, message: `Failed to install command: ${error}` };
+  }
+}
+function uninstallCommand(commandName, skillName) {
+  const config = loadConfig();
+  if (isSkillInstalled(skillName)) {
+    return {
+      success: false,
+      message: `Command belongs to installed skill '${skillName}'. Uninstall the skill to remove this command.`
+    };
+  }
+  const commandsPath = getCommandsInstallPath(config.platform);
+  const cmdPart = commandName.startsWith(skillName + " ") ? commandName.slice(skillName.length + 1) : commandName;
+  const possibleFilenames = [
+    cmdPart + ".md",
+    cmdPart.replace(/\s+/g, "-") + ".md"
+  ];
+  for (const filename of possibleFilenames) {
+    const commandPath = join6(commandsPath, filename);
+    if (existsSync4(commandPath)) {
+      try {
+        rmSync(commandPath);
+        return { success: true, message: `Uninstalled /${commandName}` };
+      } catch (error) {
+        return { success: false, message: `Failed to uninstall command: ${error}` };
+      }
+    }
+  }
+  return { success: false, message: `Command not installed: ${commandName}` };
+}
+export {
+  AIToolValue as AITool,
+  BuiltInOutput,
+  ConfigOptionType,
+  Platform,
+  SkillStatus,
+  checkForUpdates,
+  compareSemver,
+  configExists,
+  ensureConfigDir,
+  findSkillPath,
+  getAITag,
+  getAutoUpdateConfig,
+  getBundledSkills,
+  getBundledSkillsDir,
+  getCommandsInstallPath,
+  getConfigDir,
+  getConfigPath,
+  getConfigValue,
+  getInstalledSkill,
+  getPlatformConfigPath,
+  getPlatformTools,
+  getSkillOverridesPath,
+  getSkillStatusDisplay,
+  getSkillUpdateStatus,
+  getSkillsInstallPath,
+  getSkillsWithUpdates,
+  getUpdateInfo,
+  getVersion,
+  installCommand,
+  installSkill,
+  isCommandInstalled,
+  isSkillInstalled,
+  loadConfig,
+  loadSkillManifest,
+  loadSkillOverrides,
+  runUpdate,
+  saveConfig,
+  saveSkillOverrides,
+  setAutoUpdateConfig,
+  setConfigValue,
+  setPlatformTools,
+  uninstallCommand,
+  uninstallSkill,
+  updateAllSkills,
+  updatePlatformConfigSkills,
+  updateSkill
+};