@powerformer/refly-cli 0.1.22 → 0.1.24

package/dist/index.js

@@ -185,17 +185,829 @@ var init_logger = __esm({
   }
 });
 
+// src/platform/registry.ts
+function pathExists(p) {
+  try {
+    return fs5.existsSync(p);
+  } catch {
+    return false;
+  }
+}
+var fs5, path5, import_node_os, home, agents;
+var init_registry = __esm({
+  "src/platform/registry.ts"() {
+    "use strict";
+    init_cjs_shims();
+    fs5 = __toESM(require("fs"));
+    path5 = __toESM(require("path"));
+    import_node_os = require("os");
+    home = (0, import_node_os.homedir)();
+    agents = {
+      // === SKILL.md Format (Symlink Compatible) ===
+      "claude-code": {
+        name: "claude-code",
+        displayName: "Claude Code",
+        format: "skill-md",
+        skillsDir: ".claude/skills",
+        globalSkillsDir: path5.join(home, ".claude", "skills"),
+        detectInstalled: async () => pathExists(path5.join(home, ".claude"))
+      },
+      codex: {
+        name: "codex",
+        displayName: "Codex",
+        format: "skill-md",
+        skillsDir: ".codex/skills",
+        globalSkillsDir: process.env.CODEX_HOME ? path5.join(process.env.CODEX_HOME, "skills") : path5.join(home, ".codex", "skills"),
+        detectInstalled: async () => pathExists(path5.join(home, ".codex"))
+      },
+      antigravity: {
+        name: "antigravity",
+        displayName: "Antigravity",
+        format: "skill-md",
+        skillsDir: ".agent/skills",
+        globalSkillsDir: path5.join(home, ".gemini", "antigravity", "skills"),
+        detectInstalled: async () => pathExists(path5.join(home, ".gemini", "antigravity"))
+      },
+      "github-copilot": {
+        name: "github-copilot",
+        displayName: "GitHub Copilot",
+        format: "skill-md",
+        skillsDir: ".github/skills",
+        globalSkillsDir: path5.join(home, ".copilot", "skills"),
+        detectInstalled: async () => pathExists(path5.join(home, ".copilot"))
+      },
+      windsurf: {
+        name: "windsurf",
+        displayName: "Windsurf",
+        format: "skill-md",
+        skillsDir: ".windsurf/skills",
+        globalSkillsDir: path5.join(home, ".codeium", "windsurf", "skills"),
+        detectInstalled: async () => pathExists(path5.join(home, ".codeium", "windsurf"))
+      },
+      opencode: {
+        name: "opencode",
+        displayName: "OpenCode",
+        format: "skill-md",
+        skillsDir: ".opencode/skill",
+        globalSkillsDir: path5.join(home, ".config", "opencode", "skill"),
+        detectInstalled: async () => pathExists(path5.join(home, ".config", "opencode"))
+      },
+      moltbot: {
+        name: "moltbot",
+        displayName: "Moltbot",
+        format: "skill-md",
+        skillsDir: "skills",
+        // <workspace>/skills
+        globalSkillsDir: path5.join(home, ".clawdbot", "skills"),
+        // Note: .clawdbot not .moltbot
+        detectInstalled: async () => pathExists(path5.join(home, ".clawdbot"))
+      },
+      // === Different Formats (Require Conversion) ===
+      cursor: {
+        name: "cursor",
+        displayName: "Cursor",
+        format: "cursor-mdc",
+        skillsDir: ".cursor/rules",
+        globalSkillsDir: null,
+        // Cursor has no global rules directory
+        detectInstalled: async () => pathExists(path5.join(home, ".cursor")),
+        fileExtension: ".mdc",
+        skillsAsFiles: true
+      },
+      continue: {
+        name: "continue",
+        displayName: "Continue",
+        format: "rules-md",
+        skillsDir: ".continue/rules",
+        globalSkillsDir: path5.join(home, ".continue", "rules"),
+        detectInstalled: async () => pathExists(path5.join(home, ".continue")),
+        fileExtension: ".md",
+        skillsAsFiles: true
+      },
+      trae: {
+        name: "trae",
+        displayName: "Trae",
+        format: "rules-md",
+        skillsDir: ".trae/rules",
+        globalSkillsDir: path5.join(home, ".trae", "rules"),
+        detectInstalled: async () => pathExists(path5.join(home, ".trae")),
+        fileExtension: ".md",
+        skillsAsFiles: true
+      },
+      // === Unverified ===
+      qoder: {
+        name: "qoder",
+        displayName: "Qoder",
+        format: "unknown",
+        skillsDir: ".qoder/skills",
+        // Assumed, not verified
+        globalSkillsDir: path5.join(home, ".qoder", "skills"),
+        detectInstalled: async () => pathExists(path5.join(home, ".qoder"))
+      }
+    };
+  }
+});
+
+// src/platform/symlink-adapter.ts
+async function createSymlinkSafe(target, linkPath) {
+  try {
+    const linkDir = path6.dirname(linkPath);
+    ensureDir(linkDir);
+    if (fs6.existsSync(linkPath)) {
+      const stat = fs6.lstatSync(linkPath);
+      if (stat.isSymbolicLink()) {
+        fs6.unlinkSync(linkPath);
+        logger.debug(`Removed existing symlink: ${linkPath}`);
+      } else if (stat.isDirectory()) {
+        return {
+          success: false,
+          error: `Target path is a directory, not a symlink: ${linkPath}`
+        };
+      }
+    }
+    const symlinkType = (0, import_node_os2.platform)() === "win32" ? "junction" : "dir";
+    fs6.symlinkSync(target, linkPath, symlinkType);
+    logger.debug(`Created symlink: ${linkPath} -> ${target}`);
+    return { success: true };
+  } catch (err) {
+    if (err.code === "ENOENT") {
+      try {
+        const symlinkType = (0, import_node_os2.platform)() === "win32" ? "junction" : "dir";
+        fs6.symlinkSync(target, linkPath, symlinkType);
+        logger.debug(`Created symlink: ${linkPath} -> ${target}`);
+        return { success: true };
+      } catch (innerErr) {
+        return {
+          success: false,
+          error: innerErr.message
+        };
+      }
+    }
+    return {
+      success: false,
+      error: err.message
+    };
+  }
+}
+var fs6, path6, import_node_os2, SymlinkAdapter, symlinkAdapter;
+var init_symlink_adapter = __esm({
+  "src/platform/symlink-adapter.ts"() {
+    "use strict";
+    init_cjs_shims();
+    fs6 = __toESM(require("fs"));
+    path6 = __toESM(require("path"));
+    import_node_os2 = require("os");
+    init_logger();
+    init_paths();
+    SymlinkAdapter = class {
+      async deploy(skillName, sourcePath, agent, options) {
+        const result = {
+          success: false,
+          agent: agent.name,
+          skillName,
+          deployedPath: null,
+          sourcePath,
+          isSymlink: true
+        };
+        let targetDir = null;
+        if (options?.projectPath && agent.skillsDir) {
+          targetDir = path6.join(options.projectPath, agent.skillsDir);
+        } else {
+          targetDir = agent.globalSkillsDir;
+        }
+        if (!targetDir) {
+          result.error = `Agent ${agent.displayName} has no skills directory configured`;
+          return result;
+        }
+        if (!fs6.existsSync(sourcePath)) {
+          result.error = `Source skill directory does not exist: ${sourcePath}`;
+          return result;
+        }
+        const linkPath = path6.join(targetDir, skillName);
+        result.deployedPath = linkPath;
+        if (fs6.existsSync(linkPath) && !options?.force) {
+          const stat = fs6.lstatSync(linkPath);
+          if (stat.isSymbolicLink()) {
+            const existingTarget = fs6.readlinkSync(linkPath);
+            const resolvedTarget = path6.resolve(path6.dirname(linkPath), existingTarget);
+            if (resolvedTarget === sourcePath) {
+              result.success = true;
+              return result;
+            }
+          }
+          result.error = `Skill already exists at ${linkPath}. Use --force to overwrite.`;
+          return result;
+        }
+        const symlinkResult = await createSymlinkSafe(sourcePath, linkPath);
+        if (!symlinkResult.success) {
+          result.error = symlinkResult.error;
+          return result;
+        }
+        result.success = true;
+        logger.info(`Deployed ${skillName} to ${agent.displayName}: ${linkPath} -> ${sourcePath}`);
+        return result;
+      }
+      async remove(skillName, agent, options) {
+        const result = {
+          success: false,
+          agent: agent.name,
+          skillName,
+          removedPath: null
+        };
+        let targetDir = null;
+        if (options?.projectPath && agent.skillsDir) {
+          targetDir = path6.join(options.projectPath, agent.skillsDir);
+        } else {
+          targetDir = agent.globalSkillsDir;
+        }
+        if (!targetDir) {
+          result.error = `Agent ${agent.displayName} has no skills directory configured`;
+          return result;
+        }
+        const linkPath = path6.join(targetDir, skillName);
+        result.removedPath = linkPath;
+        try {
+          if (!fs6.existsSync(linkPath)) {
+            result.success = true;
+            return result;
+          }
+          const stat = fs6.lstatSync(linkPath);
+          if (!stat.isSymbolicLink()) {
+            result.error = `Path is not a symlink: ${linkPath}`;
+            return result;
+          }
+          fs6.unlinkSync(linkPath);
+          result.success = true;
+          logger.info(`Removed ${skillName} from ${agent.displayName}: ${linkPath}`);
+        } catch (err) {
+          result.error = err.message;
+        }
+        return result;
+      }
+      async list(agent, options) {
+        const results = [];
+        let targetDir = null;
+        if (options?.projectPath && agent.skillsDir) {
+          targetDir = path6.join(options.projectPath, agent.skillsDir);
+        } else {
+          targetDir = agent.globalSkillsDir;
+        }
+        if (!targetDir || !fs6.existsSync(targetDir)) {
+          return results;
+        }
+        try {
+          const entries = fs6.readdirSync(targetDir, { withFileTypes: true });
+          for (const entry of entries) {
+            const fullPath = path6.join(targetDir, entry.name);
+            try {
+              const stat = fs6.lstatSync(fullPath);
+              if (stat.isSymbolicLink()) {
+                const target = fs6.readlinkSync(fullPath);
+                const resolvedTarget = path6.resolve(path6.dirname(fullPath), target);
+                const isValid2 = fs6.existsSync(resolvedTarget);
+                results.push({
+                  name: entry.name,
+                  agent: agent.name,
+                  path: fullPath,
+                  isValid: isValid2,
+                  target: resolvedTarget,
+                  isSymlink: true
+                });
+              } else if (stat.isDirectory()) {
+                const skillMdPath = path6.join(fullPath, "SKILL.md");
+                results.push({
+                  name: entry.name,
+                  agent: agent.name,
+                  path: fullPath,
+                  isValid: fs6.existsSync(skillMdPath),
+                  isSymlink: false
+                });
+              }
+            } catch {
+            }
+          }
+        } catch {
+        }
+        return results;
+      }
+      async isDeployed(skillName, agent, options) {
+        let targetDir = null;
+        if (options?.projectPath && agent.skillsDir) {
+          targetDir = path6.join(options.projectPath, agent.skillsDir);
+        } else {
+          targetDir = agent.globalSkillsDir;
+        }
+        if (!targetDir) {
+          return { deployed: false, valid: false };
+        }
+        const linkPath = path6.join(targetDir, skillName);
+        try {
+          if (!fs6.existsSync(linkPath)) {
+            return { deployed: false, valid: false };
+          }
+          const stat = fs6.lstatSync(linkPath);
+          if (!stat.isSymbolicLink()) {
+            const skillMdPath = path6.join(linkPath, "SKILL.md");
+            return {
+              deployed: true,
+              valid: fs6.existsSync(skillMdPath),
+              path: linkPath
+            };
+          }
+          const target = fs6.readlinkSync(linkPath);
+          const resolvedTarget = path6.resolve(path6.dirname(linkPath), target);
+          const isValid2 = fs6.existsSync(resolvedTarget);
+          return {
+            deployed: true,
+            valid: isValid2,
+            path: linkPath
+          };
+        } catch {
+          return { deployed: false, valid: false };
+        }
+      }
+    };
+    symlinkAdapter = new SymlinkAdapter();
+  }
+});
+
+// src/platform/format-converter.ts
+function convertToMdc(skill) {
+  const lines = [];
+  lines.push("---");
+  lines.push(`description: "${skill.description.replace(/"/g, '\\"')}"`);
+  lines.push("globs:");
+  lines.push("alwaysApply: false");
+  lines.push("---");
+  lines.push("");
+  lines.push(`# ${skill.displayName || formatSkillName(skill.name)}`);
+  lines.push("");
+  lines.push(skill.description);
+  lines.push("");
+  lines.push(skill.body);
+  if (skill.skillId || skill.workflowId) {
+    lines.push("");
+    lines.push("---");
+    lines.push("");
+    lines.push("## Refly Skill");
+    lines.push("");
+    if (skill.skillId) {
+      lines.push(`- **Skill ID**: ${skill.skillId}`);
+    }
+    if (skill.workflowId) {
+      lines.push(`- **Workflow ID**: ${skill.workflowId}`);
+    }
+    if (skill.installationId) {
+      lines.push(`- **Installation ID**: ${skill.installationId}`);
+    }
+    const runId = skill.installationId || skill.workflowId || skill.name;
+    lines.push(`- **Run**: \`refly skill run ${runId}\``);
+  }
+  return lines.join("\n");
+}
+function convertToRules(skill) {
+  const lines = [];
+  lines.push(`# ${skill.displayName || formatSkillName(skill.name)}`);
+  lines.push("");
+  lines.push(`> ${skill.description}`);
+  lines.push("");
+  if (skill.triggers && skill.triggers.length > 0) {
+    lines.push("## Triggers");
+    lines.push("");
+    for (const trigger of skill.triggers) {
+      lines.push(`- ${trigger}`);
+    }
+    lines.push("");
+  }
+  lines.push(skill.body);
+  if (skill.skillId || skill.workflowId) {
+    lines.push("");
+    lines.push("---");
+    lines.push("");
+    lines.push("## Refly Skill");
+    lines.push("");
+    if (skill.skillId) {
+      lines.push(`- **Skill ID**: ${skill.skillId}`);
+    }
+    if (skill.workflowId) {
+      lines.push(`- **Workflow ID**: ${skill.workflowId}`);
+    }
+    if (skill.installationId) {
+      lines.push(`- **Installation ID**: ${skill.installationId}`);
+    }
+    const runId = skill.installationId || skill.workflowId || skill.name;
+    lines.push(`- **Run**: \`refly skill run ${runId}\``);
+  }
+  return lines.join("\n");
+}
+function formatSkillName(name) {
+  return name.split("-").map((w) => w.charAt(0).toUpperCase() + w.slice(1)).join(" ");
+}
+function parseSkillMdLenient(content) {
+  const frontmatterRegex = /^---\n([\s\S]*?)\n---\n?([\s\S]*)$/;
+  const match = content.match(frontmatterRegex);
+  if (!match) {
+    return null;
+  }
+  const [, frontmatterStr, body] = match;
+  const meta = {};
+  const lines = frontmatterStr.split("\n");
+  let currentKey = null;
+  let currentArray = [];
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (trimmed.startsWith("- ")) {
+      if (currentKey) {
+        currentArray.push(trimmed.slice(2).trim());
+      }
+      continue;
+    }
+    if (currentKey && currentArray.length > 0) {
+      meta[currentKey] = currentArray;
+      currentArray = [];
+      currentKey = null;
+    }
+    const colonIndex = trimmed.indexOf(":");
+    if (colonIndex > 0) {
+      const key = trimmed.slice(0, colonIndex).trim();
+      const value = trimmed.slice(colonIndex + 1).trim();
+      if (value === "") {
+        currentKey = key;
+        currentArray = [];
+      } else {
+        meta[key] = value;
+      }
+    }
+  }
+  if (currentKey && currentArray.length > 0) {
+    meta[currentKey] = currentArray;
+  }
+  if (!meta.name || !meta.description) {
+    return null;
+  }
+  return {
+    name: meta.name,
+    displayName: meta.displayName,
+    description: meta.description,
+    skillId: meta.skillId,
+    workflowId: meta.workflowId,
+    installationId: meta.installationId,
+    triggers: meta.triggers,
+    tags: meta.tags,
+    version: meta.version,
+    body: body.trim()
+  };
+}
+function readSkillMd(sourcePath) {
+  const skillMdPath = path7.join(sourcePath, "SKILL.md");
+  if (!fs7.existsSync(skillMdPath)) {
+    return null;
+  }
+  try {
+    const content = fs7.readFileSync(skillMdPath, "utf-8");
+    return parseSkillMdLenient(content);
+  } catch {
+    return null;
+  }
+}
+var fs7, path7, FormatConverterAdapter, formatConverterAdapter;
+var init_format_converter = __esm({
+  "src/platform/format-converter.ts"() {
+    "use strict";
+    init_cjs_shims();
+    fs7 = __toESM(require("fs"));
+    path7 = __toESM(require("path"));
+    init_logger();
+    init_paths();
+    FormatConverterAdapter = class {
+      async deploy(skillName, sourcePath, agent, options) {
+        const result = {
+          success: false,
+          agent: agent.name,
+          skillName,
+          deployedPath: null,
+          sourcePath,
+          isSymlink: false
+          // We generate files, not symlinks
+        };
+        let targetDir = null;
+        if (options?.projectPath && agent.skillsDir) {
+          targetDir = path7.join(options.projectPath, agent.skillsDir);
+        } else {
+          targetDir = agent.globalSkillsDir;
+        }
+        if (!targetDir) {
+          result.success = true;
+          logger.debug(`Skipping ${skillName} for ${agent.displayName}: no global skills directory`);
+          return result;
+        }
+        const skill = readSkillMd(sourcePath);
+        if (!skill) {
+          result.error = `Failed to read SKILL.md from ${sourcePath}`;
+          return result;
+        }
+        const extension = agent.fileExtension || ".md";
+        const filePath = path7.join(targetDir, `${skillName}${extension}`);
+        result.deployedPath = filePath;
+        if (fs7.existsSync(filePath) && !options?.force) {
+          result.error = `Skill already exists at ${filePath}. Use --force to overwrite.`;
+          return result;
+        }
+        let content;
+        switch (agent.format) {
+          case "cursor-mdc":
+            content = convertToMdc(skill);
+            break;
+          case "rules-md":
+            content = convertToRules(skill);
+            break;
+          default:
+            result.error = `Unsupported format: ${agent.format}`;
+            return result;
+        }
+        try {
+          ensureDir(targetDir);
+          fs7.writeFileSync(filePath, content, { encoding: "utf-8", mode: 420 });
+          result.success = true;
+          logger.info(`Deployed ${skillName} to ${agent.displayName}: ${filePath}`);
+        } catch (err) {
+          result.error = err.message;
+        }
+        return result;
+      }
+      async remove(skillName, agent, options) {
+        const result = {
+          success: false,
+          agent: agent.name,
+          skillName,
+          removedPath: null
+        };
+        let targetDir = null;
+        if (options?.projectPath && agent.skillsDir) {
+          targetDir = path7.join(options.projectPath, agent.skillsDir);
+        } else {
+          targetDir = agent.globalSkillsDir;
+        }
+        if (!targetDir) {
+          result.success = true;
+          logger.debug(
+            `Skipping ${skillName} removal for ${agent.displayName}: no global skills directory`
+          );
+          return result;
+        }
+        const extension = agent.fileExtension || ".md";
+        const filePath = path7.join(targetDir, `${skillName}${extension}`);
+        result.removedPath = filePath;
+        try {
+          if (!fs7.existsSync(filePath)) {
+            result.success = true;
+            return result;
+          }
+          fs7.unlinkSync(filePath);
+          result.success = true;
+          logger.info(`Removed ${skillName} from ${agent.displayName}: ${filePath}`);
+        } catch (err) {
+          result.error = err.message;
+        }
+        return result;
+      }
+      async list(agent, options) {
+        const results = [];
+        let targetDir = null;
+        if (options?.projectPath && agent.skillsDir) {
+          targetDir = path7.join(options.projectPath, agent.skillsDir);
+        } else {
+          targetDir = agent.globalSkillsDir;
+        }
+        if (!targetDir || !fs7.existsSync(targetDir)) {
+          return results;
+        }
+        const extension = agent.fileExtension || ".md";
+        try {
+          const entries = fs7.readdirSync(targetDir, { withFileTypes: true });
+          for (const entry of entries) {
+            if (entry.isFile() && entry.name.endsWith(extension)) {
+              const fullPath = path7.join(targetDir, entry.name);
+              const skillName = entry.name.slice(0, -extension.length);
+              let isReflySkill = false;
+              try {
+                const content = fs7.readFileSync(fullPath, "utf-8");
+                isReflySkill = content.includes("## Refly Skill") || content.includes("Skill ID:");
+              } catch {
+              }
+              results.push({
+                name: skillName,
+                agent: agent.name,
+                path: fullPath,
+                isValid: isReflySkill,
+                isSymlink: false
+              });
+            }
+          }
+        } catch {
+        }
+        return results;
+      }
+      async isDeployed(skillName, agent, options) {
+        let targetDir = null;
+        if (options?.projectPath && agent.skillsDir) {
+          targetDir = path7.join(options.projectPath, agent.skillsDir);
+        } else {
+          targetDir = agent.globalSkillsDir;
+        }
+        if (!targetDir) {
+          return { deployed: false, valid: false };
+        }
+        const extension = agent.fileExtension || ".md";
+        const filePath = path7.join(targetDir, `${skillName}${extension}`);
+        if (!fs7.existsSync(filePath)) {
+          return { deployed: false, valid: false };
+        }
+        let isValid2 = false;
+        try {
+          const content = fs7.readFileSync(filePath, "utf-8");
+          isValid2 = content.includes("## Refly Skill") || content.includes("Skill ID:");
+        } catch {
+        }
+        return {
+          deployed: true,
+          valid: isValid2,
+          path: filePath
+        };
+      }
+    };
+    formatConverterAdapter = new FormatConverterAdapter();
+  }
+});
+
+// src/platform/manager.ts
+function getAdapter(agent) {
+  switch (agent.format) {
+    case "skill-md":
+      return symlinkAdapter;
+    case "cursor-mdc":
+    case "rules-md":
+      return formatConverterAdapter;
+    default:
+      return symlinkAdapter;
+  }
+}
+async function detectInstalledAgents() {
+  const installed = [];
+  for (const agent of Object.values(agents)) {
+    try {
+      const isInstalled = await agent.detectInstalled();
+      if (isInstalled) {
+        installed.push(agent);
+      }
+    } catch (err) {
+      logger.debug(`Error detecting ${agent.displayName}: ${err.message}`);
+    }
+  }
+  return installed;
+}
+async function getDeployableAgents(options) {
+  const installed = await detectInstalledAgents();
+  if (options?.includeUnknown) {
+    return installed;
+  }
+  return installed.filter((agent) => agent.format !== "unknown");
+}
+async function deploySkillToAllPlatforms(skillName, options) {
+  const sourcePath = skillName === "refly" ? getReflyBaseSkillDir() : getReflyDomainSkillDir(skillName);
+  const result = {
+    skillName,
+    sourcePath,
+    results: /* @__PURE__ */ new Map(),
+    successCount: 0,
+    failureCount: 0
+  };
+  if (!fs8.existsSync(sourcePath)) {
+    logger.error(`Source skill directory does not exist: ${sourcePath}`);
+    return result;
+  }
+  let targetAgents;
+  if (options?.agents && options.agents.length > 0) {
+    targetAgents = options.agents.map((name) => agents[name]).filter(Boolean);
+  } else {
+    targetAgents = await getDeployableAgents();
+  }
+  for (const agent of targetAgents) {
+    const adapter = getAdapter(agent);
+    try {
+      const deployResult = await adapter.deploy(skillName, sourcePath, agent, {
+        force: options?.force,
+        projectPath: options?.projectPath
+      });
+      result.results.set(agent.name, deployResult);
+      if (deployResult.success) {
+        result.successCount++;
+      } else {
+        result.failureCount++;
+      }
+    } catch (err) {
+      result.results.set(agent.name, {
+        success: false,
+        agent: agent.name,
+        skillName,
+        deployedPath: null,
+        sourcePath,
+        isSymlink: false,
+        error: err.message
+      });
+      result.failureCount++;
+    }
+  }
+  return result;
+}
+async function removeSkillFromAllPlatforms(skillName, options) {
+  const result = {
+    skillName,
+    results: /* @__PURE__ */ new Map(),
+    successCount: 0,
+    failureCount: 0
+  };
+  let targetAgents;
+  if (options?.agents && options.agents.length > 0) {
+    targetAgents = options.agents.map((name) => agents[name]).filter(Boolean);
+  } else {
+    targetAgents = await getDeployableAgents();
+  }
+  for (const agent of targetAgents) {
+    const adapter = getAdapter(agent);
+    try {
+      const removeResult = await adapter.remove(skillName, agent, {
+        projectPath: options?.projectPath
+      });
+      result.results.set(agent.name, removeResult);
+      if (removeResult.success) {
+        result.successCount++;
+      } else {
+        result.failureCount++;
+      }
+    } catch (err) {
+      result.results.set(agent.name, {
+        success: false,
+        agent: agent.name,
+        skillName,
+        removedPath: null,
+        error: err.message
+      });
+      result.failureCount++;
+    }
+  }
+  return result;
+}
+async function listAllDeployedSkills(options) {
+  const result = /* @__PURE__ */ new Map();
+  let targetAgents;
+  if (options?.agents && options.agents.length > 0) {
+    targetAgents = options.agents.map((name) => agents[name]).filter(Boolean);
+  } else {
+    targetAgents = await getDeployableAgents();
+  }
+  for (const agent of targetAgents) {
+    const adapter = getAdapter(agent);
+    try {
+      const skills = await adapter.list(agent, {
+        projectPath: options?.projectPath
+      });
+      result.set(agent.name, skills);
+    } catch (err) {
+      logger.debug(`Error listing skills for ${agent.displayName}: ${err.message}`);
+      result.set(agent.name, []);
+    }
+  }
+  return result;
+}
+var fs8;
+var init_manager = __esm({
+  "src/platform/manager.ts"() {
+    "use strict";
+    init_cjs_shims();
+    fs8 = __toESM(require("fs"));
+    init_registry();
+    init_symlink_adapter();
+    init_format_converter();
+    init_paths();
+    init_logger();
+  }
+});
+
 // src/skill/symlink.ts
 var symlink_exports = {};
 __export(symlink_exports, {
+  createMultiPlatformSkill: () => createMultiPlatformSkill,
   createReflySkillWithSymlink: () => createReflySkillWithSymlink,
   createSkillSymlink: () => createSkillSymlink,
   deleteDomainSkillWithSymlink: () => deleteDomainSkillWithSymlink,
   generateReflySkillMd: () => generateReflySkillMd,
   initializeBaseSkillSymlink: () => initializeBaseSkillSymlink,
   isSkillSymlinkValid: () => isSkillSymlinkValid,
+  listMultiPlatformSkills: () => listMultiPlatformSkills,
   listSkillSymlinks: () => listSkillSymlinks,
   parseReflySkillMd: () => parseReflySkillMd,
+  removeMultiPlatformSkill: () => removeMultiPlatformSkill,
   removeSkillSymlink: () => removeSkillSymlink
 });
 function createSkillSymlink(skillName) {
@@ -204,7 +1016,7 @@ function createSkillSymlink(skillName) {
   try {
     ensureReflySkillsDir();
     ensureClaudeSkillsDir();
-    if (!fs5.existsSync(reflyPath)) {
+    if (!fs9.existsSync(reflyPath)) {
       return {
         success: false,
         skillName,
@@ -213,10 +1025,10 @@ function createSkillSymlink(skillName) {
         error: `Source skill directory does not exist: ${reflyPath}`
       };
     }
-    if (fs5.existsSync(claudePath) || fs5.lstatSync(claudePath).isSymbolicLink()) {
-      const stat = fs5.lstatSync(claudePath);
+    if (fs9.existsSync(claudePath) || fs9.lstatSync(claudePath).isSymbolicLink()) {
+      const stat = fs9.lstatSync(claudePath);
       if (stat.isSymbolicLink()) {
-        fs5.unlinkSync(claudePath);
+        fs9.unlinkSync(claudePath);
         logger.debug(`Removed existing symlink: ${claudePath}`);
       } else if (stat.isDirectory()) {
         logger.warn(`Cannot create symlink: ${claudePath} is a directory, not a symlink`);
@@ -229,7 +1041,7 @@ function createSkillSymlink(skillName) {
         };
       }
     }
-    fs5.symlinkSync(reflyPath, claudePath, "dir");
+    fs9.symlinkSync(reflyPath, claudePath, "dir");
     logger.info(`Created symlink: ${claudePath} -> ${reflyPath}`);
     return {
       success: true,
@@ -240,7 +1052,7 @@ function createSkillSymlink(skillName) {
   } catch (err) {
     if (err.code === "ENOENT") {
       try {
-        fs5.symlinkSync(reflyPath, claudePath, "dir");
+        fs9.symlinkSync(reflyPath, claudePath, "dir");
         logger.info(`Created symlink: ${claudePath} -> ${reflyPath}`);
         return {
           success: true,
@@ -270,16 +1082,16 @@ function createSkillSymlink(skillName) {
 function removeSkillSymlink(skillName) {
   const claudePath = getClaudeSkillSymlinkPath(skillName);
   try {
-    if (!fs5.existsSync(claudePath)) {
+    if (!fs9.existsSync(claudePath)) {
       logger.debug(`Symlink not found: ${claudePath}`);
       return false;
     }
-    const stat = fs5.lstatSync(claudePath);
+    const stat = fs9.lstatSync(claudePath);
     if (!stat.isSymbolicLink()) {
       logger.warn(`Not a symlink: ${claudePath}`);
       return false;
     }
-    fs5.unlinkSync(claudePath);
+    fs9.unlinkSync(claudePath);
     logger.info(`Removed symlink: ${claudePath}`);
     return true;
   } catch (err) {
@@ -291,16 +1103,16 @@ function isSkillSymlinkValid(skillName) {
   const claudePath = getClaudeSkillSymlinkPath(skillName);
   const expectedTarget = skillName === "refly" ? getReflyBaseSkillDir() : getReflyDomainSkillDir(skillName);
   try {
-    if (!fs5.existsSync(claudePath)) {
+    if (!fs9.existsSync(claudePath)) {
       return { exists: false, isSymlink: false, isValid: false };
     }
-    const stat = fs5.lstatSync(claudePath);
+    const stat = fs9.lstatSync(claudePath);
     if (!stat.isSymbolicLink()) {
       return { exists: true, isSymlink: false, isValid: false };
     }
-    const target = fs5.readlinkSync(claudePath);
-    const resolvedTarget = path5.resolve(path5.dirname(claudePath), target);
-    const isValid2 = resolvedTarget === expectedTarget && fs5.existsSync(resolvedTarget);
+    const target = fs9.readlinkSync(claudePath);
+    const resolvedTarget = path8.resolve(path8.dirname(claudePath), target);
+    const isValid2 = resolvedTarget === expectedTarget && fs9.existsSync(resolvedTarget);
     return {
       exists: true,
       isSymlink: true,
@@ -314,17 +1126,17 @@ function isSkillSymlinkValid(skillName) {
 function initializeBaseSkillSymlink() {
   const baseDir = getReflyBaseSkillDir();
   ensureDir(baseDir);
-  ensureDir(path5.join(baseDir, "rules"));
+  ensureDir(path8.join(baseDir, "rules"));
   return createSkillSymlink("refly");
 }
 function createReflySkillWithSymlink(skillName, skillMdContent, options) {
   const skillDir = getReflyDomainSkillDir(skillName);
   try {
     ensureReflySkillsDir();
-    if (fs5.existsSync(skillDir)) {
+    if (fs9.existsSync(skillDir)) {
       if (options?.force) {
-        const skillMdPath2 = path5.join(skillDir, "SKILL.md");
-        fs5.writeFileSync(skillMdPath2, skillMdContent, { encoding: "utf-8", mode: 420 });
+        const skillMdPath2 = path8.join(skillDir, "SKILL.md");
+        fs9.writeFileSync(skillMdPath2, skillMdContent, { encoding: "utf-8", mode: 420 });
         logger.debug(`Updated SKILL.md (force): ${skillMdPath2}`);
         return createSkillSymlink(skillName);
       }
@@ -336,9 +1148,9 @@ function createReflySkillWithSymlink(skillName, skillMdContent, options) {
         error: `Skill directory already exists: ${skillDir}`
       };
     }
-    fs5.mkdirSync(skillDir, { recursive: true, mode: 493 });
-    const skillMdPath = path5.join(skillDir, "SKILL.md");
-    fs5.writeFileSync(skillMdPath, skillMdContent, { encoding: "utf-8", mode: 420 });
+    fs9.mkdirSync(skillDir, { recursive: true, mode: 493 });
+    const skillMdPath = path8.join(skillDir, "SKILL.md");
+    fs9.writeFileSync(skillMdPath, skillMdContent, { encoding: "utf-8", mode: 420 });
     logger.debug(`Created SKILL.md: ${skillMdPath}`);
     return createSkillSymlink(skillName);
   } catch (err) {
@@ -356,8 +1168,8 @@ function deleteDomainSkillWithSymlink(skillName) {
   const skillDir = getReflyDomainSkillDir(skillName);
   let directoryRemoved = false;
   try {
-    if (fs5.existsSync(skillDir)) {
-      fs5.rmSync(skillDir, { recursive: true, force: true });
+    if (fs9.existsSync(skillDir)) {
+      fs9.rmSync(skillDir, { recursive: true, force: true });
       directoryRemoved = true;
       logger.info(`Removed skill directory: ${skillDir}`);
     }
@@ -369,19 +1181,19 @@ function deleteDomainSkillWithSymlink(skillName) {
 function listSkillSymlinks() {
   const claudeSkillsDir = getClaudeSkillsDir();
   const results = [];
-  if (!fs5.existsSync(claudeSkillsDir)) {
+  if (!fs9.existsSync(claudeSkillsDir)) {
     return results;
   }
   try {
-    const entries = fs5.readdirSync(claudeSkillsDir, { withFileTypes: true });
+    const entries = fs9.readdirSync(claudeSkillsDir, { withFileTypes: true });
     for (const entry of entries) {
-      const fullPath = path5.join(claudeSkillsDir, entry.name);
+      const fullPath = path8.join(claudeSkillsDir, entry.name);
       try {
-        const stat = fs5.lstatSync(fullPath);
+        const stat = fs9.lstatSync(fullPath);
         if (stat.isSymbolicLink()) {
-          const target = fs5.readlinkSync(fullPath);
-          const resolvedTarget = path5.resolve(path5.dirname(fullPath), target);
-          const isValid2 = fs5.existsSync(resolvedTarget);
+          const target = fs9.readlinkSync(fullPath);
+          const resolvedTarget = path8.resolve(path8.dirname(fullPath), target);
+          const isValid2 = fs9.existsSync(resolvedTarget);
           results.push({
             name: entry.name,
             claudePath: fullPath,
@@ -396,6 +1208,12 @@ function listSkillSymlinks() {
   }
   return results;
 }
+function escapeYamlValue(value) {
+  if (value.includes(":") || value.includes("#") || value.includes("'") || value.includes('"') || value.includes("\n") || value.startsWith(" ") || value.endsWith(" ") || value.startsWith("[") || value.startsWith("{")) {
+    return `"${value.replace(/\\/g, "\\\\").replace(/"/g, '\\"')}"`;
+  }
+  return value;
+}
 function generateReflySkillMd(options) {
   const {
     name,
@@ -410,21 +1228,21 @@ function generateReflySkillMd(options) {
     inputSchema,
     outputSchema
   } = options;
-  const frontmatterLines = ["---", `name: ${name}`];
-  frontmatterLines.push(`description: ${description}`);
+  const frontmatterLines = ["---", `name: ${escapeYamlValue(name)}`];
+  frontmatterLines.push(`description: ${escapeYamlValue(description)}`);
   if (tags.length > 0) {
     frontmatterLines.push("tags:");
-    frontmatterLines.push(...tags.map((t) => `  - ${t}`));
+    frontmatterLines.push(...tags.map((t) => `  - ${escapeYamlValue(t)}`));
   }
-  frontmatterLines.push(`version: ${version}`);
-  frontmatterLines.push(`skillId: ${skillId}`);
-  frontmatterLines.push(`workflowId: ${workflowId}`);
+  frontmatterLines.push(`version: ${escapeYamlValue(version)}`);
+  frontmatterLines.push(`skillId: ${escapeYamlValue(skillId)}`);
+  frontmatterLines.push(`workflowId: ${escapeYamlValue(workflowId)}`);
   if (installationId) {
-    frontmatterLines.push(`installationId: ${installationId}`);
+    frontmatterLines.push(`installationId: ${escapeYamlValue(installationId)}`);
   }
   if (triggers.length > 0) {
     frontmatterLines.push("triggers:");
-    frontmatterLines.push(...triggers.map((t) => `  - ${t}`));
+    frontmatterLines.push(...triggers.map((t) => `  - ${escapeYamlValue(t)}`));
   }
   frontmatterLines.push("---");
   const title = displayName || name.split("-").map((w) => w.charAt(0).toUpperCase() + w.slice(1)).join(" ");
@@ -443,14 +1261,6 @@ ${JSON.stringify(outputSchema, null, 2)}
 
 ${description}
 
-## Usage
-
-This skill is executed via Refly CLI:
-
-\`\`\`bash
-${runCommand}
-\`\`\`
-
 ## Input
 
 Provide input as JSON:
@@ -459,16 +1269,42 @@ Provide input as JSON:
 ${inputExample}
 \`\`\`
 
+## Execution
+
+**Follow this exact 4-step pattern:**
+
+\`\`\`bash
+# Step 1: Run and capture RUN_ID (we-xxx format)
+RESULT=$(${runCommand})
+RUN_ID=$(echo "$RESULT" | jq -r '.payload.workflowExecutions[0].id')
+# RUN_ID is we-xxx format, use this for workflow commands below
+
+# Step 2: Wait for completion (use RUN_ID, not installationId)
+refly workflow status "$RUN_ID" --watch --interval 30000
+
+# Step 3: Get files from this run (use RUN_ID)
+FILES=$(refly workflow toolcalls "$RUN_ID" --files --latest | jq -r '.payload.files[]')
+
+# Step 4: Download and open each file
+echo "$FILES" | jq -c '.' | while read -r file; do
+  FILE_ID=$(echo "$file" | jq -r '.fileId')
+  FILE_NAME=$(echo "$file" | jq -r '.name')
+  if [ -n "$FILE_ID" ] && [ "$FILE_ID" != "null" ]; then
+    OUTPUT_PATH="$HOME/Desktop/$FILE_NAME"
+    refly file download "$FILE_ID" -o "$OUTPUT_PATH"
+    open "$OUTPUT_PATH"
+  fi
+done
+\`\`\`
+
 ## Output
 
 ${outputSection}
 
 ## Rules
 
-For workflow operations, refer to the base skill rules:
-- Workflow: \`~/.claude/skills/refly/rules/workflow.md\`
-- Node: \`~/.claude/skills/refly/rules/node.md\`
-- File: \`~/.claude/skills/refly/rules/file.md\`
+For workflow operations, refer to the base skill:
+- Base skill: \`~/.claude/skills/refly/SKILL.md\`
 `;
   return frontmatterLines.join("\n") + content;
 }
@@ -529,15 +1365,79 @@ function parseReflySkillMd(content) {
     raw: content
   };
 }
-var fs5, path5;
+async function createMultiPlatformSkill(skillName, skillMdContent, options) {
+  const skillDir = getReflyDomainSkillDir(skillName);
+  ensureReflySkillsDir();
+  if (fs9.existsSync(skillDir)) {
+    if (options?.force) {
+      const skillMdPath = path8.join(skillDir, "SKILL.md");
+      fs9.writeFileSync(skillMdPath, skillMdContent, { encoding: "utf-8", mode: 420 });
+      logger.debug(`Updated SKILL.md (force): ${skillMdPath}`);
+    } else {
+      return {
+        skillName,
+        sourcePath: skillDir,
+        results: /* @__PURE__ */ new Map(),
+        successCount: 0,
+        failureCount: 1
+      };
+    }
+  } else {
+    fs9.mkdirSync(skillDir, { recursive: true, mode: 493 });
+    const skillMdPath = path8.join(skillDir, "SKILL.md");
+    fs9.writeFileSync(skillMdPath, skillMdContent, { encoding: "utf-8", mode: 420 });
+    logger.debug(`Created SKILL.md: ${skillMdPath}`);
+  }
+  return deploySkillToAllPlatforms(skillName, {
+    force: options?.force,
+    agents: options?.agents
+  });
+}
+async function removeMultiPlatformSkill(skillName, options) {
+  const platformResults = await removeSkillFromAllPlatforms(skillName, {
+    agents: options?.agents
+  });
+  let directoryRemoved = false;
+  if (!options?.keepLocal) {
+    const skillDir = getReflyDomainSkillDir(skillName);
+    try {
+      if (fs9.existsSync(skillDir)) {
+        fs9.rmSync(skillDir, { recursive: true, force: true });
+        directoryRemoved = true;
+        logger.info(`Removed skill directory: ${skillDir}`);
+      }
+    } catch (err) {
+      logger.error(`Failed to remove skill directory ${skillDir}:`, err);
+    }
+  }
+  return { platformResults, directoryRemoved };
+}
+async function listMultiPlatformSkills(options) {
+  const allDeployed = await listAllDeployedSkills({ agents: options?.agents });
+  const result = /* @__PURE__ */ new Map();
+  for (const [agent, skills] of allDeployed) {
+    result.set(
+      agent,
+      skills.map((s) => ({
+        name: s.name,
+        path: s.path,
+        isValid: s.isValid,
+        isSymlink: s.isSymlink
+      }))
+    );
+  }
+  return result;
+}
+var fs9, path8;
 var init_symlink = __esm({
   "src/skill/symlink.ts"() {
     "use strict";
     init_cjs_shims();
-    fs5 = __toESM(require("fs"));
-    path5 = __toESM(require("path"));
+    fs9 = __toESM(require("fs"));
+    path8 = __toESM(require("path"));
     init_paths();
     init_logger();
+    init_manager();
   }
 });
 
@@ -1196,8 +2096,8 @@ function getErrorMap() {
 // ../../node_modules/.pnpm/zod@3.25.76/node_modules/zod/v3/helpers/parseUtil.js
 init_cjs_shims();
 var makeIssue = (params) => {
-  const { data, path: path7, errorMaps, issueData } = params;
-  const fullPath = [...path7, ...issueData.path || []];
+  const { data, path: path10, errorMaps, issueData } = params;
+  const fullPath = [...path10, ...issueData.path || []];
   const fullIssue = {
     ...issueData,
     path: fullPath
@@ -1317,11 +2217,11 @@ var errorUtil;
 
 // ../../node_modules/.pnpm/zod@3.25.76/node_modules/zod/v3/types.js
 var ParseInputLazyPath = class {
-  constructor(parent, value, path7, key) {
+  constructor(parent, value, path10, key) {
     this._cachedPath = [];
     this.parent = parent;
     this.data = value;
-    this._path = path7;
+    this._path = path10;
     this._key = key;
   }
   get path() {
@@ -4765,6 +5665,23 @@ var NEVER = INVALID;
 
 // src/config/config.ts
 init_paths();
+var AgentTypeEnum = external_exports.enum([
+  "claude-code",
+  "codex",
+  "antigravity",
+  "github-copilot",
+  "windsurf",
+  "opencode",
+  "moltbot",
+  "cursor",
+  "continue",
+  "trae",
+  "qoder"
+]);
+var PlatformConfigSchema = external_exports.object({
+  enabled: external_exports.boolean().default(true),
+  globalPath: external_exports.string().optional()
+});
 var ConfigSchema = external_exports.object({
   version: external_exports.number().default(1),
   auth: external_exports.object({
@@ -4792,9 +5709,11 @@ var ConfigSchema = external_exports.object({
   skill: external_exports.object({
     installedVersion: external_exports.string().optional(),
     installedAt: external_exports.string().optional()
-  }).optional()
+  }).optional(),
+  // Multi-platform configuration
+  platforms: external_exports.record(AgentTypeEnum, PlatformConfigSchema).optional()
 });
-var DEFAULT_API_ENDPOINT = "https://staging-api.refly.ai";
+var DEFAULT_API_ENDPOINT = "https://api.refly.ai";
 var DEFAULT_CONFIG = {
   version: 1,
   api: {
@@ -4899,10 +5818,10 @@ var path4 = __toESM(require("path"));
 var import_mime = __toESM(require("mime"));
 init_logger();
 var DEFAULT_TIMEOUT = 3e4;
-async function apiRequest(path7, options = {}) {
+async function apiRequest(path10, options = {}) {
   const { method = "GET", body, query, timeout = DEFAULT_TIMEOUT, requireAuth = true } = options;
   const endpoint = getApiEndpoint();
-  let url = `${endpoint}${path7}`;
+  let url = `${endpoint}${path10}`;
   if (query && Object.keys(query).length > 0) {
     const params = new URLSearchParams(query);
     url = `${url}?${params.toString()}`;
@@ -4940,7 +5859,7 @@ async function apiRequest(path7, options = {}) {
   const controller = new AbortController();
   const timeoutId = setTimeout(() => controller.abort(), timeout);
   try {
-    logger.debug(`API Request: ${method} ${path7}`);
+    logger.debug(`API Request: ${method} ${path10}`);
     const response = await fetch(url, {
       method,
       headers,
@@ -5086,22 +6005,22 @@ async function verifyConnection() {
 
 // src/skill/installer.ts
 init_cjs_shims();
-var fs6 = __toESM(require("fs"));
-var path6 = __toESM(require("path"));
+var fs10 = __toESM(require("fs"));
+var path9 = __toESM(require("path"));
 init_paths();
 init_logger();
 init_symlink();
 function removeOldSkillDirectory() {
   const claudeSkillPath = getClaudeSkillSymlinkPath("refly");
-  if (!fs6.existsSync(claudeSkillPath)) {
+  if (!fs10.existsSync(claudeSkillPath)) {
     return;
   }
   try {
-    const stat = fs6.lstatSync(claudeSkillPath);
+    const stat = fs10.lstatSync(claudeSkillPath);
     if (stat.isSymbolicLink()) {
-      fs6.unlinkSync(claudeSkillPath);
+      fs10.unlinkSync(claudeSkillPath);
     } else if (stat.isDirectory()) {
-      fs6.rmSync(claudeSkillPath, { recursive: true, force: true });
+      fs10.rmSync(claudeSkillPath, { recursive: true, force: true });
       logger.info("Removed old skill directory");
     }
   } catch (err) {
@@ -5110,17 +6029,17 @@ function removeOldSkillDirectory() {
 }
 function getPackageSkillDir() {
   const possiblePaths = [
-    path6.join(__dirname, "..", "..", "skill"),
+    path9.join(__dirname, "..", "..", "skill"),
     // Built package: dist/bin/../../skill
-    path6.join(__dirname, "..", "..", "..", "skill"),
+    path9.join(__dirname, "..", "..", "..", "skill"),
     // Development: dist/bin/../../../skill
-    path6.join(__dirname, "..", "skill")
+    path9.join(__dirname, "..", "skill")
     // Alternative: dist/../skill
   ];
   logger.debug("Looking for skill files, __dirname:", __dirname);
   for (const p of possiblePaths) {
-    const resolved = path6.resolve(p);
-    const exists = fs6.existsSync(resolved);
+    const resolved = path9.resolve(p);
+    const exists = fs10.existsSync(resolved);
     logger.debug(`  Checking path: ${resolved} - exists: ${exists}`);
     if (exists) {
       return resolved;
@@ -5144,30 +6063,30 @@ function installSkill() {
   logger.debug("Target skill directory:", targetDir);
   try {
     ensureDir(targetDir);
-    ensureDir(path6.join(targetDir, "rules"));
+    ensureDir(path9.join(targetDir, "rules"));
     logger.debug("Created target directories");
   } catch (err) {
     logger.error("Failed to create target directories:", err);
     throw err;
   }
-  const skillSource = path6.join(sourceDir, "SKILL.md");
-  const skillTarget = path6.join(targetDir, "SKILL.md");
+  const skillSource = path9.join(sourceDir, "SKILL.md");
+  const skillTarget = path9.join(targetDir, "SKILL.md");
   logger.debug(`Copying SKILL.md: ${skillSource} -> ${skillTarget}`);
-  if (fs6.existsSync(skillSource)) {
-    fs6.copyFileSync(skillSource, skillTarget);
+  if (fs10.existsSync(skillSource)) {
+    fs10.copyFileSync(skillSource, skillTarget);
     result.skillInstalled = true;
     result.skillPath = targetDir;
     logger.debug("SKILL.md copied successfully");
   } else {
     logger.warn("SKILL.md source not found:", skillSource);
   }
-  const refsSource = path6.join(sourceDir, "references");
-  const rulesTarget = path6.join(targetDir, "rules");
-  if (fs6.existsSync(refsSource)) {
-    const files = fs6.readdirSync(refsSource);
+  const refsSource = path9.join(sourceDir, "references");
+  const rulesTarget = path9.join(targetDir, "rules");
+  if (fs10.existsSync(refsSource)) {
+    const files = fs10.readdirSync(refsSource);
     logger.debug(`Copying ${files.length} rule files`);
     for (const file of files) {
-      fs6.copyFileSync(path6.join(refsSource, file), path6.join(rulesTarget, file));
+      fs10.copyFileSync(path9.join(refsSource, file), path9.join(rulesTarget, file));
     }
   }
   removeOldSkillDirectory();
@@ -5195,15 +6114,15 @@ function installSkill() {
   return result;
 }
 function installSlashCommands(sourceDir, targetDir) {
-  const commandsSource = path6.join(sourceDir, "..", "commands");
-  if (!fs6.existsSync(commandsSource)) {
+  const commandsSource = path9.join(sourceDir, "..", "commands");
+  if (!fs10.existsSync(commandsSource)) {
     return false;
   }
   try {
-    const files = fs6.readdirSync(commandsSource);
+    const files = fs10.readdirSync(commandsSource);
     for (const file of files) {
       if (file.endsWith(".md")) {
-        fs6.copyFileSync(path6.join(commandsSource, file), path6.join(targetDir, file));
+        fs10.copyFileSync(path9.join(commandsSource, file), path9.join(targetDir, file));
       }
     }
     return files.length > 0;
@@ -5213,8 +6132,8 @@ function installSlashCommands(sourceDir, targetDir) {
 }
 function getSkillVersion() {
   try {
-    const skillPath = path6.join(getPackageSkillDir(), "SKILL.md");
-    const content = fs6.readFileSync(skillPath, "utf-8");
+    const skillPath = path9.join(getPackageSkillDir(), "SKILL.md");
+    const content = fs10.readFileSync(skillPath, "utf-8");
     const versionMatch = content.match(/version:\s*(\d+\.\d+\.\d+)/);
     if (versionMatch) {
       return versionMatch[1];
@@ -5222,16 +6141,16 @@ function getSkillVersion() {
   } catch {
   }
   try {
-    const pkgPath = path6.join(__dirname, "..", "..", "package.json");
-    const pkg = JSON.parse(fs6.readFileSync(pkgPath, "utf-8"));
+    const pkgPath = path9.join(__dirname, "..", "..", "package.json");
+    const pkg = JSON.parse(fs10.readFileSync(pkgPath, "utf-8"));
     return pkg.version;
   } catch {
     return "0.1.0";
   }
 }
 function isSkillInstalled() {
-  const skillPath = path6.join(getReflyBaseSkillDir(), "SKILL.md");
-  if (!fs6.existsSync(skillPath)) {
+  const skillPath = path9.join(getReflyBaseSkillDir(), "SKILL.md");
+  if (!fs10.existsSync(skillPath)) {
     return { installed: false, upToDate: false };
   }
   const currentVersion = getSkillVersion();