skillsmgr 0.5.0 → 0.5.1

package/dist/index.js

@@ -1,6 +1,7 @@
 #!/usr/bin/env node
 
 // src/index.ts
+import { createRequire } from "module";
 import { Command as Command9 } from "commander";
 
 // src/commands/setup.ts
@@ -53,6 +54,13 @@ function copyFile(src, dest) {
   ensureDir(dirname(dest));
   copyFileSync(src, dest);
 }
+function linkFile(src, dest) {
+  ensureDir(dirname(dest));
+  if (existsSync(dest)) {
+    unlinkSync(dest);
+  }
+  symlinkSync(src, dest);
+}
 function isSymlink(path) {
   try {
     return lstatSync(path).isSymbolicLink();
@@ -77,11 +85,26 @@ function writeFile(path, content) {
 function fileExists(path) {
   return existsSync(path);
 }
+function removeFile(path) {
+  if (existsSync(path)) {
+    unlinkSync(path);
+  }
+}
 function removeDir(dir) {
   if (existsSync(dir)) {
     rmSync(dir, { recursive: true, force: true });
   }
 }
+function getFilesInDir(dir, ext) {
+  if (!existsSync(dir)) {
+    return [];
+  }
+  const entries = readdirSync(dir, { withFileTypes: true });
+  return entries.filter((e) => e.isFile() && (!ext || e.name.endsWith(ext))).map((e) => ({
+    name: e.name,
+    path: join2(dir, e.name)
+  })).sort((a, b) => a.name.localeCompare(b.name));
+}
 function getDirectoriesInDir(dir) {
   if (!existsSync(dir)) {
     return [];
@@ -319,6 +342,52 @@ var GitHubService = class {
     const content = await response.text();
     writeFileSync2(localPath, content, "utf-8");
   }
+  /**
+   * List commands (.md files) in a GitHub repository's commands directory
+   */
+  async listCommands(owner, repo, commandsPath = "commands") {
+    const url = `${this.baseApiUrl}/repos/${owner}/${repo}/contents/${commandsPath}`;
+    const response = await fetch(url, {
+      headers: this.getHeaders()
+    });
+    if (!response.ok) {
+      return [];
+    }
+    const contents = await response.json();
+    return contents.filter((item) => item.type === "file" && item.name.endsWith(".md")).map((item) => ({ name: item.name, path: item.path }));
+  }
+  /**
+   * Download a single command file from GitHub
+   */
+  async downloadCommandFile(owner, repo, filePath, targetPath) {
+    ensureDir(join5(targetPath, ".."));
+    const url = `${this.baseApiUrl}/repos/${owner}/${repo}/contents/${filePath}`;
+    const response = await fetch(url, {
+      headers: this.getHeaders()
+    });
+    if (!response.ok) {
+      throw new Error(`Failed to download command: ${response.statusText}`);
+    }
+    const content = await response.json();
+    if (content.download_url) {
+      await this.downloadFile(content.download_url, targetPath);
+    }
+  }
+  /**
+   * Get the target directory for commands based on source
+   */
+  getCommandsTargetDir(owner, repo, isCustom = false) {
+    const isAnthropic = owner === "anthropics" && repo === "skills";
+    let baseDir;
+    if (isAnthropic) {
+      baseDir = join5(SKILLS_MANAGER_DIR, "official", "anthropic");
+    } else if (isCustom) {
+      baseDir = join5(SKILLS_MANAGER_DIR, "custom", repo);
+    } else {
+      baseDir = join5(SKILLS_MANAGER_DIR, "community", repo);
+    }
+    return join5(baseDir, "commands");
+  }
   /**
    * Get the target directory for a skill based on source
    */
@@ -426,13 +495,14 @@ var TOOL_CONFIGS = {
     name: "antigravity",
     displayName: "Antigravity",
     skillsDir: ".agent/skills",
+    commandsDir: ".agent/workflows",
     supportsLink: true,
     supportsModeSpecific: false
   },
   "codex-cli": {
     name: "codex-cli",
     displayName: "Codex CLI",
-    skillsDir: ".agents/skills",
+    skillsDir: ".codex/skills",
     supportsLink: true,
     supportsModeSpecific: false
   },
@@ -440,6 +510,7 @@ var TOOL_CONFIGS = {
     name: "roo-code",
     displayName: "Roo Code",
     skillsDir: ".roo/skills",
+    commandsDir: ".roo/commands",
     supportsLink: true,
     supportsModeSpecific: true,
     modePattern: "skills-{mode}",
@@ -449,6 +520,7 @@ var TOOL_CONFIGS = {
     name: "claude-code",
     displayName: "Claude Code",
     skillsDir: ".claude/skills",
+    commandsDir: ".claude/commands",
     supportsLink: true,
     supportsModeSpecific: false
   },
@@ -456,6 +528,7 @@ var TOOL_CONFIGS = {
     name: "gemini-cli",
     displayName: "Gemini CLI",
     skillsDir: ".gemini/skills",
+    commandsDir: ".gemini/commands",
     supportsLink: true,
     supportsModeSpecific: false
   },
@@ -463,6 +536,7 @@ var TOOL_CONFIGS = {
     name: "opencode",
     displayName: "OpenCode",
     skillsDir: ".opencode/skills",
+    commandsDir: ".opencode/commands",
     supportsLink: true,
     supportsModeSpecific: false
   },
@@ -477,6 +551,7 @@ var TOOL_CONFIGS = {
     name: "cursor",
     displayName: "Cursor",
     skillsDir: ".cursor/skills",
+    commandsDir: ".cursor/commands",
     supportsLink: true,
     supportsModeSpecific: false
   },
@@ -484,6 +559,7 @@ var TOOL_CONFIGS = {
     name: "kilo-code",
     displayName: "Kilo Code",
     skillsDir: ".kilocode/skills",
+    commandsDir: ".kilocode/commands",
     supportsLink: true,
     supportsModeSpecific: true,
     modePattern: "skills-{mode}",
@@ -500,6 +576,7 @@ var TOOL_CONFIGS = {
     name: "windsurf",
     displayName: "Windsurf",
     skillsDir: ".windsurf/skills",
+    commandsDir: ".windsurf/workflows",
     supportsLink: true,
     supportsModeSpecific: false
   }
@@ -823,6 +900,34 @@ async function promptSkills(skills, deployedSkillNames = []) {
     pageSize: 15
   });
 }
+async function promptCommands(commands, deployedCommandNames = []) {
+  const grouped = {};
+  for (const command of commands) {
+    if (!grouped[command.source]) {
+      grouped[command.source] = [];
+    }
+    grouped[command.source].push(command);
+  }
+  const choices = [];
+  for (const [source, sourceCommands] of Object.entries(grouped)) {
+    for (const command of sourceCommands) {
+      const isDeployed = deployedCommandNames.includes(command.name);
+      choices.push({
+        name: `/${command.name}`,
+        description: command.description,
+        value: command.name,
+        checked: isDeployed,
+        group: source,
+        suffix: isDeployed ? "[deployed]" : void 0
+      });
+    }
+  }
+  return interactiveCheckbox({
+    message: "Select commands to deploy:",
+    choices,
+    pageSize: 15
+  });
+}
 async function promptSkillsToInstall(skills) {
   const choices = skills.map((skill) => ({
     name: skill.name,
@@ -850,18 +955,19 @@ async function promptSelect(message, choices) {
     handlePromptError(error);
   }
 }
-async function promptSyncAction(filename) {
+async function promptSyncAction(filename, showDiff = true) {
+  const choices = [
+    { name: "Overwrite", value: "overwrite" },
+    { name: "Skip", value: "skip" },
+    ...showDiff ? [{ name: "Show diff", value: "diff" }] : []
+  ];
   try {
     const { action } = await inquirer.prompt([
       {
         type: "list",
         name: "action",
         message: `${filename}: source changed`,
-        choices: [
-          { name: "Overwrite", value: "overwrite" },
-          { name: "Skip", value: "skip" },
-          { name: "Show diff", value: "diff" }
-        ]
+        choices
       }
     ]);
     return action;
@@ -942,7 +1048,7 @@ var ProgressBar = class {
 
 // src/commands/install.ts
 var sourcesService = new SourcesService();
-function parseSkillDescription(content) {
+function parseMdDescription(content) {
   const frontmatterMatch = content.match(/^---\n([\s\S]*?)\n---/);
   if (!frontmatterMatch) {
     return "";
@@ -950,17 +1056,58 @@ function parseSkillDescription(content) {
   const descMatch = frontmatterMatch[1].match(/^description:\s*(.+)$/m);
   return descMatch ? descMatch[1].trim() : "";
 }
+async function installCommandsFromGitHub(githubService2, owner, repo, targetBase, defaultBranch) {
+  const commandsPaths = ["commands", "src/commands"];
+  let commandsList = [];
+  for (const commandsPath of commandsPaths) {
+    commandsList = await githubService2.listCommands(owner, repo, commandsPath);
+    if (commandsList.length > 0) break;
+  }
+  if (commandsList.length === 0) {
+    return 0;
+  }
+  console.log(`
+Found ${commandsList.length} commands, installing...`);
+  const commandsTargetDir = join7(targetBase, "commands");
+  ensureDir(commandsTargetDir);
+  for (const cmd of commandsList) {
+    const targetPath = join7(commandsTargetDir, cmd.name);
+    process.stdout.write(`  ${cmd.name.replace(/\.md$/, "")}...`);
+    await githubService2.downloadCommandFile(owner, repo, cmd.path, targetPath);
+    console.log(" \u2713");
+  }
+  return commandsList.length;
+}
 async function installFromAnthropic(options) {
   const githubService2 = new GitHubService();
   const owner = "anthropics";
   const repo = "skills";
   console.log("Fetching available skills from anthropic/skills...");
   const skillsList = await githubService2.listSkills(owner, repo, "skills");
+  const defaultBranch = await githubService2.getDefaultBranch(owner, repo);
+  const targetBase = join7(SKILLS_MANAGER_DIR, "official", "anthropic");
+  let commandsCount = 0;
   if (skillsList.length === 0) {
-    console.log("No skills found in repository");
+    commandsCount = await installCommandsFromGitHub(
+      githubService2,
+      owner,
+      repo,
+      targetBase,
+      defaultBranch
+    );
+    if (commandsCount === 0) {
+      console.error("Error: No skills or commands found in repository");
+      process.exit(1);
+    }
+    console.log(`
+\u2713 Installed ${commandsCount} commands to ${targetBase}`);
+    sourcesService.addSource("official/anthropic", {
+      url: "https://github.com/anthropics/skills",
+      type: "official",
+      repoName: "anthropic"
+    });
     return;
   }
-  const defaultBranch = await githubService2.getDefaultBranch(owner, repo);
   const skills = [];
   const progress = new ProgressBar(skillsList.length, "Fetching skill info");
   progress.start();
@@ -971,7 +1118,7 @@ async function installFromAnthropic(options) {
       );
       if (response.ok) {
         const content = await response.text();
-        const description = parseSkillDescription(content);
+        const description = parseMdDescription(content);
         skills.push({
           name: skill.name,
           description,
@@ -999,15 +1146,23 @@ async function installFromAnthropic(options) {
   }
   console.log(`
 Downloading ${selectedSkills.length} skills...`);
-  const targetBase = join7(SKILLS_MANAGER_DIR, "official", "anthropic");
   for (const skill of selectedSkills) {
     const targetDir = join7(targetBase, skill.name);
     process.stdout.write(`  ${skill.name}...`);
     await githubService2.downloadSkill(owner, repo, skill.path, targetDir);
     console.log(" \u2713");
   }
+  commandsCount = await installCommandsFromGitHub(
+    githubService2,
+    owner,
+    repo,
+    targetBase,
+    defaultBranch
+  );
+  const parts = [`${selectedSkills.length} skills`];
+  if (commandsCount > 0) parts.push(`${commandsCount} commands`);
   console.log(`
-\u2713 Installed ${selectedSkills.length} skills to ${targetBase}`);
+\u2713 Installed ${parts.join(" and ")} to ${targetBase}`);
   sourcesService.addSource("official/anthropic", {
     url: "https://github.com/anthropics/skills",
     type: "official",
@@ -1030,7 +1185,7 @@ async function installFromGitHubUrl(url, options) {
     console.log(`\u2713 Installed ${skillName} to ${targetDir}`);
     return true;
   }
-  console.log(`Fetching available skills from ${owner}/${repo}...`);
+  console.log(`Fetching available content from ${owner}/${repo}...`);
   let skillsList = [];
   const skillsPaths = ["skills", ".", "src/skills"];
   for (const skillsPath of skillsPaths) {
@@ -1041,10 +1196,36 @@ async function installFromGitHubUrl(url, options) {
       continue;
     }
   }
+  const defaultBranch = await githubService2.getDefaultBranch(owner, repo);
+  let targetBase;
+  if (isAnthropic) {
+    targetBase = join7(SKILLS_MANAGER_DIR, "official", "anthropic");
+  } else if (options.custom) {
+    targetBase = join7(SKILLS_MANAGER_DIR, "custom", repo);
+  } else {
+    targetBase = join7(SKILLS_MANAGER_DIR, "community", repo);
+  }
   if (skillsList.length === 0) {
-    return false;
+    const commandsCount2 = await installCommandsFromGitHub(
+      githubService2,
+      owner,
+      repo,
+      targetBase,
+      defaultBranch
+    );
+    if (commandsCount2 === 0) {
+      return false;
+    }
+    console.log(`
+\u2713 Installed ${commandsCount2} commands to ${targetBase}`);
+    const sourceKey2 = isAnthropic ? "official/anthropic" : options.custom ? `custom/${repo}` : `community/${repo}`;
+    sourcesService.addSource(sourceKey2, {
+      url: `https://github.com/${owner}/${repo}`,
+      type: isAnthropic ? "official" : options.custom ? "custom" : "community",
+      repoName: repo
+    });
+    return true;
   }
-  const defaultBranch = await githubService2.getDefaultBranch(owner, repo);
   const skills = [];
   const progress = new ProgressBar(skillsList.length, "Fetching skill info");
   progress.start();
@@ -1055,7 +1236,7 @@ async function installFromGitHubUrl(url, options) {
       );
       if (response.ok) {
         const content = await response.text();
-        const description = parseSkillDescription(content);
+        const description = parseMdDescription(content);
         skills.push({ name: skill.name, description, path: skill.path });
       }
     } catch {
@@ -1064,7 +1245,25 @@ async function installFromGitHubUrl(url, options) {
   }
   progress.complete();
   if (skills.length === 0) {
-    return false;
+    const commandsCount2 = await installCommandsFromGitHub(
+      githubService2,
+      owner,
+      repo,
+      targetBase,
+      defaultBranch
+    );
+    if (commandsCount2 === 0) {
+      return false;
+    }
+    console.log(`
+\u2713 Installed ${commandsCount2} commands to ${targetBase}`);
+    const sourceKey2 = isAnthropic ? "official/anthropic" : options.custom ? `custom/${repo}` : `community/${repo}`;
+    sourcesService.addSource(sourceKey2, {
+      url: `https://github.com/${owner}/${repo}`,
+      type: isAnthropic ? "official" : options.custom ? "custom" : "community",
+      repoName: repo
+    });
+    return true;
   }
   console.log(`Found ${skills.length} skills.
 `);
@@ -1079,22 +1278,23 @@ async function installFromGitHubUrl(url, options) {
   }
   console.log(`
 Downloading ${selectedSkills.length} skills...`);
-  let targetBase;
-  if (isAnthropic) {
-    targetBase = join7(SKILLS_MANAGER_DIR, "official", "anthropic");
-  } else if (options.custom) {
-    targetBase = join7(SKILLS_MANAGER_DIR, "custom", repo);
-  } else {
-    targetBase = join7(SKILLS_MANAGER_DIR, "community", repo);
-  }
   for (const skill of selectedSkills) {
     const targetDir = join7(targetBase, skill.name);
     process.stdout.write(`  ${skill.name}...`);
     await githubService2.downloadSkill(owner, repo, skill.path, targetDir);
     console.log(" \u2713");
   }
+  const commandsCount = await installCommandsFromGitHub(
+    githubService2,
+    owner,
+    repo,
+    targetBase,
+    defaultBranch
+  );
+  const parts = [`${selectedSkills.length} skills`];
+  if (commandsCount > 0) parts.push(`${commandsCount} commands`);
   console.log(`
-\u2713 Installed ${selectedSkills.length} skills to ${targetBase}`);
+\u2713 Installed ${parts.join(" and ")} to ${targetBase}`);
   const sourceKey = isAnthropic ? "official/anthropic" : options.custom ? `custom/${repo}` : `community/${repo}`;
   sourcesService.addSource(sourceKey, {
     url: `https://github.com/${owner}/${repo}`,
@@ -1103,6 +1303,17 @@ Downloading ${selectedSkills.length} skills...`);
   });
   return true;
 }
+function countCommandsInRepo(repoPath) {
+  const commandsDirs = ["commands", "src/commands"];
+  for (const dir of commandsDirs) {
+    const commandsDir = join7(repoPath, dir);
+    if (fileExists(commandsDir)) {
+      const mdFiles = getFilesInDir(commandsDir, ".md");
+      return mdFiles.length;
+    }
+  }
+  return 0;
+}
 async function installViaGitClone(source, options) {
   const gitService = new GitService();
   if (gitService.isSpecificSkillUrl(source)) {
@@ -1129,7 +1340,7 @@ async function installViaGitClone(source, options) {
     const skillMdPath = join7(dir.path, "SKILL.md");
     if (fileExists(skillMdPath)) {
       const content = readFileContent(skillMdPath);
-      const description = parseSkillDescription(content);
+      const description = parseMdDescription(content);
       skills.push({
         name: dir.name,
         description,
@@ -1137,14 +1348,28 @@ async function installViaGitClone(source, options) {
       });
     }
   }
+  const commandsCount = countCommandsInRepo(repoPath);
+  if (skills.length === 0 && commandsCount === 0) {
+    console.error("Error: No skills or commands found in repository");
+    process.exit(1);
+  }
+  if (skills.length > 0) {
+    console.log(`Found ${skills.length} skills.
+`);
+  }
+  if (commandsCount > 0) {
+    console.log(`Found ${commandsCount} commands (will be installed automatically).
+`);
+  }
   if (skills.length === 0) {
-    console.log("No skills found in repository");
+    console.log(`\u2713 Installed ${commandsCount} commands to ${repoPath}`);
+    saveGitCloneSource(source, repoPath, options);
     return;
   }
-  console.log(`Found ${skills.length} skills.
-`);
   if (options.all) {
-    console.log(`\u2713 Installed ${skills.length} skills to ${repoPath}`);
+    const parts2 = [`${skills.length} skills`];
+    if (commandsCount > 0) parts2.push(`${commandsCount} commands`);
+    console.log(`\u2713 Installed ${parts2.join(" and ")} to ${repoPath}`);
     saveGitCloneSource(source, repoPath, options);
     return;
   }
@@ -1158,8 +1383,10 @@ async function installViaGitClone(source, options) {
   for (const skill of unselectedSkills) {
     removeDir(skill.path);
   }
+  const parts = [`${selectedNames.length} skills`];
+  if (commandsCount > 0) parts.push(`${commandsCount} commands`);
   console.log(`
-\u2713 Installed ${selectedNames.length} skills to ${repoPath}`);
+\u2713 Installed ${parts.join(" and ")} to ${repoPath}`);
   saveGitCloneSource(source, repoPath, options);
 }
 function saveGitCloneSource(source, repoPath, options) {
@@ -1198,6 +1425,10 @@ async function executeInstall(source, options) {
       await installFromAnthropic(options);
       return;
     }
+    if (!source.includes("://") && /^[^/]+\/[^/]+\/?$/.test(source)) {
+      source = `https://github.com/${source.replace(/\/$/, "")}`;
+      console.log(`Resolved to ${source}`);
+    }
     if (source.includes("github.com")) {
       const success = await installFromGitHubUrl(source, options);
       if (success) return;
@@ -1211,7 +1442,7 @@ async function executeInstall(source, options) {
     process.exit(1);
   }
 }
-var installCommand = new Command2("install").description("Download skills from a repository").argument("<source>", 'Repository URL or "anthropic" for official skills').option("--all", "Install all skills without prompting").option("--custom", "Install to custom/ instead of community/").action(async (source, options) => {
+var installCommand = new Command2("install").description("Download skills and commands from a repository").argument("<source>", 'Repository URL or "anthropic" for official skills').option("--all", "Install all skills without prompting").option("--custom", "Install to custom/ instead of community/").action(async (source, options) => {
   await executeInstall(source, options);
 });
 
@@ -1236,58 +1467,101 @@ async function updateSource(key, info) {
   } else {
     targetBase = join8(SKILLS_MANAGER_DIR, "community", info.repoName);
   }
-  const localSkills = getDirectoriesInDir(targetBase);
-  if (localSkills.length === 0) {
-    console.log(`  No skills installed locally`);
-    return result;
-  }
   const defaultBranch = await githubService.getDefaultBranch(owner, repo);
-  let skillsBasePath = "skills";
-  const skillsPaths = ["skills", ".", "src/skills"];
-  for (const skillsPath of skillsPaths) {
-    try {
-      const testList = await githubService.listSkills(owner, repo, skillsPath);
-      if (testList.length > 0) {
-        skillsBasePath = skillsPath;
-        break;
+  const localSkills = getDirectoriesInDir(targetBase);
+  if (localSkills.length > 0) {
+    let skillsBasePath = "skills";
+    const skillsPaths = ["skills", ".", "src/skills"];
+    for (const skillsPath of skillsPaths) {
+      try {
+        const testList = await githubService.listSkills(owner, repo, skillsPath);
+        if (testList.length > 0) {
+          skillsBasePath = skillsPath;
+          break;
+        }
+      } catch {
+        continue;
+      }
+    }
+    for (const localSkill of localSkills) {
+      const skillName = localSkill.name;
+      if (skillName === "commands") continue;
+      const targetDir = localSkill.path;
+      const localSkillMd = join8(targetDir, "SKILL.md");
+      if (!fileExists(localSkillMd)) {
+        continue;
+      }
+      const remotePath = skillsBasePath === "." ? skillName : `${skillsBasePath}/${skillName}`;
+      try {
+        const response = await fetch(
+          `https://raw.githubusercontent.com/${owner}/${repo}/${defaultBranch}/${remotePath}/SKILL.md`
+        );
+        if (!response.ok) {
+          console.log(`  \u26A0 ${skillName}: not found in remote`);
+          result.failed++;
+          continue;
+        }
+        const remoteContent = await response.text();
+        const localContent = readFileContent(localSkillMd);
+        if (remoteContent === localContent) {
+          console.log(`  \u2713 ${skillName}: up to date`);
+          result.upToDate++;
+        } else {
+          removeDir(targetDir);
+          await githubService.downloadSkill(owner, repo, remotePath, targetDir);
+          console.log(`  \u2191 ${skillName}: updated`);
+          result.updated++;
+        }
+      } catch {
+        console.log(`  \u2717 ${skillName}: failed to update`);
+        result.failed++;
       }
-    } catch {
-      continue;
     }
   }
-  for (const localSkill of localSkills) {
-    const skillName = localSkill.name;
-    const targetDir = localSkill.path;
-    const localSkillMd = join8(targetDir, "SKILL.md");
-    if (!fileExists(localSkillMd)) {
-      continue;
+  const localCommandsDir = join8(targetBase, "commands");
+  const localCommands = getFilesInDir(localCommandsDir, ".md");
+  if (localCommands.length > 0) {
+    const commandsPaths = ["commands", "src/commands"];
+    let commandsBasePath = "commands";
+    for (const commandsPath of commandsPaths) {
+      const remoteCommands = await githubService.listCommands(owner, repo, commandsPath);
+      if (remoteCommands.length > 0) {
+        commandsBasePath = commandsPath;
+        break;
+      }
     }
-    const remotePath = skillsBasePath === "." ? skillName : `${skillsBasePath}/${skillName}`;
-    try {
-      const response = await fetch(
-        `https://raw.githubusercontent.com/${owner}/${repo}/${defaultBranch}/${remotePath}/SKILL.md`
-      );
-      if (!response.ok) {
-        console.log(`  \u26A0 ${skillName}: not found in remote`);
+    for (const localCommand of localCommands) {
+      const commandName = localCommand.name.replace(/\.md$/, "");
+      const remotePath = `${commandsBasePath}/${localCommand.name}`;
+      try {
+        const response = await fetch(
+          `https://raw.githubusercontent.com/${owner}/${repo}/${defaultBranch}/${remotePath}`
+        );
+        if (!response.ok) {
+          console.log(`  \u26A0 /${commandName}: not found in remote`);
+          result.failed++;
+          continue;
+        }
+        const remoteContent = await response.text();
+        const localContent = readFileContent(localCommand.path);
+        if (remoteContent === localContent) {
+          console.log(`  \u2713 /${commandName}: up to date`);
+          result.upToDate++;
+        } else {
+          removeFile(localCommand.path);
+          await githubService.downloadCommandFile(owner, repo, remotePath, localCommand.path);
+          console.log(`  \u2191 /${commandName}: updated`);
+          result.updated++;
+        }
+      } catch {
+        console.log(`  \u2717 /${commandName}: failed to update`);
         result.failed++;
-        continue;
-      }
-      const remoteContent = await response.text();
-      const localContent = readFileContent(localSkillMd);
-      if (remoteContent === localContent) {
-        console.log(`  \u2713 ${skillName}: up to date`);
-        result.upToDate++;
-      } else {
-        removeDir(targetDir);
-        await githubService.downloadSkill(owner, repo, remotePath, targetDir);
-        console.log(`  \u2191 ${skillName}: updated`);
-        result.updated++;
       }
-    } catch {
-      console.log(`  \u2717 ${skillName}: failed to update`);
-      result.failed++;
     }
   }
+  if (localSkills.length === 0 && localCommands.length === 0) {
+    console.log(`  No skills or commands installed locally`);
+  }
   sourcesService2.updateTimestamp(key);
   return result;
 }
@@ -1335,7 +1609,7 @@ Done! ${result.updated} updated, ${result.upToDate} up to date, ${result.failed}
   }
   console.log(`Done! ${totalUpdated} updated, ${totalUpToDate} up to date, ${totalFailed} failed`);
 }
-var updateCommand = new Command3("update").description("Update installed skills to latest version").argument("[source]", 'Specific source to update (e.g., "anthropic")').action(async (source) => {
+var updateCommand = new Command3("update").description("Update installed skills and commands to latest version").argument("[source]", 'Specific source to update (e.g., "anthropic")').action(async (source) => {
   await executeUpdate(source);
 });
 
@@ -1432,16 +1706,109 @@ var SkillsService = class {
   }
 };
 
-// src/services/scanner.ts
+// src/services/commands.ts
 import { join as join10 } from "path";
+var CommandsService = class {
+  constructor(skillsDir) {
+    this.skillsDir = skillsDir;
+  }
+  getAllCommands() {
+    const commands = [];
+    for (const source of SKILL_SOURCES) {
+      const sourceDir = join10(this.skillsDir, source);
+      const sourceCommands = this.getCommandsFromSource(sourceDir, source);
+      commands.push(...sourceCommands);
+    }
+    return commands;
+  }
+  getCommandsBySource(source) {
+    const sourceDir = join10(this.skillsDir, source);
+    return this.getCommandsFromSource(sourceDir, source);
+  }
+  getCommandByName(name) {
+    const allCommands = this.getAllCommands();
+    return allCommands.find((c) => c.name === name);
+  }
+  getCommandsByNames(names) {
+    const allCommands = this.getAllCommands();
+    return names.map((name) => allCommands.find((c) => c.name === name)).filter((c) => c !== void 0);
+  }
+  findCommandsByName(name) {
+    const allCommands = this.getAllCommands();
+    return allCommands.filter((c) => c.name === name);
+  }
+  getCommandsFromSource(sourceDir, sourcePrefix) {
+    const commands = [];
+    if (!fileExists(sourceDir)) {
+      return commands;
+    }
+    if (sourcePrefix === "custom") {
+      const commandsDir = join10(sourceDir, "commands");
+      const customCommands = this.loadCommandsFromDir(commandsDir, sourcePrefix);
+      commands.push(...customCommands);
+    } else {
+      const repoDirs = getDirectoriesInDir(sourceDir);
+      for (const repoDir of repoDirs) {
+        const source = `${sourcePrefix}/${repoDir.name}`;
+        const commandsDir = join10(repoDir.path, "commands");
+        const repoCommands = this.loadCommandsFromDir(commandsDir, source);
+        commands.push(...repoCommands);
+      }
+    }
+    return commands;
+  }
+  loadCommandsFromDir(commandsDir, source) {
+    const commands = [];
+    if (!fileExists(commandsDir)) {
+      return commands;
+    }
+    const mdFiles = getFilesInDir(commandsDir, ".md");
+    for (const file of mdFiles) {
+      const command = this.loadCommand(file.path, file.name, source);
+      if (command) {
+        commands.push(command);
+      }
+    }
+    return commands;
+  }
+  loadCommand(filePath, fileName, source) {
+    const content = readFileContent(filePath);
+    const { name, description } = this.parseCommandMd(content);
+    const commandName = name || fileName.replace(/\.md$/, "");
+    return {
+      name: commandName,
+      description: description || "",
+      path: filePath,
+      source
+    };
+  }
+  parseCommandMd(content) {
+    const frontmatterMatch = content.match(/^---\n([\s\S]*?)\n---/);
+    if (!frontmatterMatch) {
+      return { name: "", description: "" };
+    }
+    const frontmatter = frontmatterMatch[1];
+    const nameMatch = frontmatter.match(/^name:\s*(.+)$/m);
+    const descMatch = frontmatter.match(/^description:\s*(.+)$/m);
+    return {
+      name: nameMatch ? nameMatch[1].trim() : "",
+      description: descMatch ? descMatch[1].trim() : ""
+    };
+  }
+};
+
+// src/services/scanner.ts
+import { join as join11 } from "path";
 import { readdirSync as readdirSync2 } from "fs";
 var DeploymentScanner = class {
   constructor(projectDir, skillsManagerDir = SKILLS_MANAGER_DIR) {
     this.projectDir = projectDir;
     this.skillsManagerDir = skillsManagerDir;
     this.skillsService = new SkillsService(this.skillsManagerDir);
+    this.commandsService = new CommandsService(this.skillsManagerDir);
   }
   skillsService;
+  commandsService;
   scanAllTools() {
     const deployments = [];
     for (const toolName of SUPPORTED_TOOLS) {
@@ -1449,19 +1816,24 @@ var DeploymentScanner = class {
       const toolDeployments = this.scanToolDeployment(toolName, config);
       deployments.push(...toolDeployments);
     }
-    return deployments.filter((d) => d.skills.length > 0);
+    return deployments.filter((d) => d.skills.length > 0 || d.commands.length > 0);
   }
   scanToolDeployment(toolName, config) {
     const deployments = [];
-    const baseDir = join10(this.projectDir, config.skillsDir);
+    const baseDir = join11(this.projectDir, config.skillsDir);
     const baseDeployment = this.scanDirectory(toolName, baseDir, config.skillsDir);
-    if (baseDeployment.skills.length > 0) {
+    if (config.commandsDir) {
+      const commandsDir = join11(this.projectDir, config.commandsDir);
+      const commands = this.scanCommandsDirectory(commandsDir);
+      baseDeployment.commands = commands;
+    }
+    if (baseDeployment.skills.length > 0 || baseDeployment.commands.length > 0) {
       deployments.push(baseDeployment);
     }
     if (config.supportsModeSpecific && config.availableModes) {
       for (const mode of config.availableModes) {
         const modeDir = getTargetDir(config, mode);
-        const fullModeDir = join10(this.projectDir, modeDir);
+        const fullModeDir = join11(this.projectDir, modeDir);
         const modeDeployment = this.scanDirectory(toolName, fullModeDir, modeDir, mode);
         if (modeDeployment.skills.length > 0) {
           deployments.push(modeDeployment);
@@ -1475,7 +1847,7 @@ var DeploymentScanner = class {
     for (const toolName of SUPPORTED_TOOLS) {
       const config = TOOL_CONFIGS[toolName];
       const deployments = this.scanToolDeployment(toolName, config);
-      if (deployments.some((d) => d.skills.length > 0)) {
+      if (deployments.some((d) => d.skills.length > 0 || d.commands.length > 0)) {
         tools.add(toolName);
       }
     }
@@ -1485,7 +1857,7 @@ var DeploymentScanner = class {
     const config = TOOL_CONFIGS[toolName];
     if (!config) return false;
     const deployments = this.scanToolDeployment(toolName, config);
-    return deployments.some((d) => d.skills.length > 0);
+    return deployments.some((d) => d.skills.length > 0 || d.commands.length > 0);
   }
   getDeployedSkills(toolName) {
     const config = TOOL_CONFIGS[toolName];
@@ -1493,12 +1865,19 @@ var DeploymentScanner = class {
     const deployments = this.scanToolDeployment(toolName, config);
     return deployments.flatMap((d) => d.skills);
   }
+  getDeployedCommands(toolName) {
+    const config = TOOL_CONFIGS[toolName];
+    if (!config || !config.commandsDir) return [];
+    const commandsDir = join11(this.projectDir, config.commandsDir);
+    return this.scanCommandsDirectory(commandsDir);
+  }
   scanDirectory(toolName, fullPath, relativePath, mode) {
     const deployment = {
       toolName,
       targetDir: relativePath,
       mode,
-      skills: []
+      skills: [],
+      commands: []
     };
     if (!fileExists(fullPath)) {
       return deployment;
@@ -1506,7 +1885,7 @@ var DeploymentScanner = class {
     try {
       const entries = readdirSync2(fullPath, { withFileTypes: true });
       for (const entry of entries) {
-        const skillPath = join10(fullPath, entry.name);
+        const skillPath = join11(fullPath, entry.name);
         const scanned = this.scanSkill(skillPath, entry.name);
         if (scanned) {
           deployment.skills.push(scanned);
@@ -1516,8 +1895,42 @@ var DeploymentScanner = class {
     }
     return deployment;
   }
+  scanCommandsDirectory(fullPath) {
+    const commands = [];
+    if (!fileExists(fullPath)) {
+      return commands;
+    }
+    try {
+      const entries = readdirSync2(fullPath, { withFileTypes: true });
+      for (const entry of entries) {
+        if (!entry.isFile() || !entry.name.endsWith(".md")) continue;
+        const commandPath = join11(fullPath, entry.name);
+        const commandName = entry.name.replace(/\.md$/, "");
+        if (isSymlink(commandPath)) {
+          const linkTarget = readSymlinkTarget(commandPath);
+          const source = linkTarget ? this.extractSourceFromPath(linkTarget) : null;
+          commands.push({
+            name: commandName,
+            source: source || "unknown",
+            deployMode: "link",
+            path: commandPath
+          });
+        } else {
+          const cmdMatch = this.commandsService.findCommandsByName(commandName);
+          commands.push({
+            name: commandName,
+            source: cmdMatch.length === 1 ? cmdMatch[0].source : "unknown",
+            deployMode: "copy",
+            path: commandPath
+          });
+        }
+      }
+    } catch {
+    }
+    return commands;
+  }
   scanSkill(skillPath, name) {
-    const skillMdPath = join10(skillPath, "SKILL.md");
+    const skillMdPath = join11(skillPath, "SKILL.md");
     if (!fileExists(skillMdPath)) {
       return null;
     }
@@ -1590,55 +2003,86 @@ async function listAvailable() {
     console.log("Skills manager not set up. Run: skillsmgr setup");
     process.exit(1);
   }
-  const service = new SkillsService(SKILLS_MANAGER_DIR);
-  const skills = service.getAllSkills();
-  if (skills.length === 0) {
-    console.log("No skills found in ~/.skills-manager/");
+  const skillsService = new SkillsService(SKILLS_MANAGER_DIR);
+  const commandsService = new CommandsService(SKILLS_MANAGER_DIR);
+  const skills = skillsService.getAllSkills();
+  const commands = commandsService.getAllCommands();
+  if (skills.length === 0 && commands.length === 0) {
+    console.log("No skills or commands found in ~/.skills-manager/");
     console.log("\nRun: skillsmgr install anthropic");
     return;
   }
-  console.log("Available skills in ~/.skills-manager/:\n");
-  const grouped = {};
-  for (const skill of skills) {
-    if (!grouped[skill.source]) {
-      grouped[skill.source] = [];
+  console.log("Available in ~/.skills-manager/:\n");
+  if (skills.length > 0) {
+    const grouped = {};
+    for (const skill of skills) {
+      if (!grouped[skill.source]) {
+        grouped[skill.source] = [];
+      }
+      grouped[skill.source].push(skill);
+    }
+    for (const [source, sourceSkills] of Object.entries(grouped)) {
+      console.log(`\u2500\u2500 ${source} (${sourceSkills.length} skill${sourceSkills.length > 1 ? "s" : ""}) \u2500\u2500`);
+      for (const skill of sourceSkills) {
+        console.log(`  ${skill.name}`);
+      }
+      console.log();
     }
-    grouped[skill.source].push(skill);
   }
-  for (const [source, sourceSkills] of Object.entries(grouped)) {
-    console.log(`\u2500\u2500 ${source} (${sourceSkills.length} skill${sourceSkills.length > 1 ? "s" : ""}) \u2500\u2500`);
-    for (const skill of sourceSkills) {
-      console.log(`  ${skill.name}`);
+  if (commands.length > 0) {
+    const grouped = {};
+    for (const command of commands) {
+      if (!grouped[command.source]) {
+        grouped[command.source] = [];
+      }
+      grouped[command.source].push(command);
+    }
+    for (const [source, sourceCommands] of Object.entries(grouped)) {
+      console.log(`\u2500\u2500 ${source} (${sourceCommands.length} command${sourceCommands.length > 1 ? "s" : ""}) \u2500\u2500`);
+      for (const command of sourceCommands) {
+        console.log(`  /${command.name}`);
+      }
+      console.log();
     }
-    console.log();
   }
 }
 async function listDeployed() {
   const scanner = new DeploymentScanner(process.cwd(), SKILLS_MANAGER_DIR);
   const deployments = scanner.scanAllTools();
   if (deployments.length === 0) {
-    console.log("No skills deployed in current project.");
+    console.log("No skills or commands deployed in current project.");
     console.log("\nRun: skillsmgr init");
     return;
   }
-  console.log("Deployed skills in current project:\n");
+  console.log("Deployed in current project:\n");
   for (const deployment of deployments) {
     const config = TOOL_CONFIGS[deployment.toolName];
     const displayName = config?.displayName || deployment.toolName;
     const dirSuffix = deployment.mode && deployment.mode !== "all" ? ` [${deployment.mode}]` : "";
-    console.log(`${displayName} (${deployment.targetDir}/)${dirSuffix}:`);
-    for (const skill of deployment.skills) {
-      const modeStr = skill.deployMode === "link" ? "link" : "copy";
-      if (skill.conflict) {
-        console.log(`  \u26A0 ${skill.name.padEnd(16)} (${modeStr}) \u2190 conflict`);
-      } else {
-        console.log(`  \u25C9 ${skill.name.padEnd(16)} (${modeStr}) \u2190 ${skill.source}`);
+    if (deployment.skills.length > 0) {
+      console.log(`${displayName} skills (${deployment.targetDir}/)${dirSuffix}:`);
+      for (const skill of deployment.skills) {
+        const modeStr = skill.deployMode === "link" ? "link" : "copy";
+        if (skill.conflict) {
+          console.log(`  \u26A0 ${skill.name.padEnd(16)} (${modeStr}) \u2190 conflict`);
+        } else {
+          console.log(`  \u25C9 ${skill.name.padEnd(16)} (${modeStr}) \u2190 ${skill.source}`);
+        }
       }
+      console.log();
+    }
+    if (deployment.commands.length > 0) {
+      const commandsDirDisplay = config?.commandsDir || "commands";
+      console.log(`${displayName} commands (${commandsDirDisplay}/):`);
+      for (const command of deployment.commands) {
+        const modeStr = command.deployMode === "link" ? "link" : "copy";
+        console.log(`  \u25C9 /${command.name.padEnd(15)} (${modeStr}) \u2190 ${command.source}`);
+      }
+      console.log();
     }
-    console.log();
   }
 }
-var listCommand = new Command4("list").description("List available or deployed skills").option("--deployed", "List deployed skills in current project").action(async (options) => {
+var listCommand = new Command4("list").description("List available or deployed skills and commands").option("--deployed", "List deployed skills and commands in current project").action(async (options) => {
   await executeList(options);
 });
 
@@ -1646,7 +2090,7 @@ var listCommand = new Command4("list").description("List available or deployed s
 import { Command as Command5 } from "commander";
 
 // src/services/deployer.ts
-import { join as join11 } from "path";
+import { join as join12 } from "path";
 import { existsSync as existsSync3, rmSync as rmSync2 } from "fs";
 var Deployer = class {
   constructor(projectDir) {
@@ -1654,9 +2098,9 @@ var Deployer = class {
   }
   deploySkill(skill, toolConfig, mode, targetMode) {
     const targetDir = getTargetDir(toolConfig, targetMode);
-    const fullTargetDir = join11(this.projectDir, targetDir);
+    const fullTargetDir = join12(this.projectDir, targetDir);
     ensureDir(fullTargetDir);
-    const skillTargetPath = join11(fullTargetDir, skill.name);
+    const skillTargetPath = join12(fullTargetDir, skill.name);
     if (mode === "link") {
       linkDir(skill.path, skillTargetPath);
     } else {
@@ -1670,19 +2114,52 @@ var Deployer = class {
   }
   removeSkill(skillName, toolConfig, targetMode) {
     const targetDir = getTargetDir(toolConfig, targetMode);
-    const skillPath = join11(this.projectDir, targetDir, skillName);
+    const skillPath = join12(this.projectDir, targetDir, skillName);
     if (existsSync3(skillPath)) {
       rmSync2(skillPath, { recursive: true, force: true });
     }
   }
   getDeployedSkillPath(skillName, toolConfig, targetMode) {
     const targetDir = getTargetDir(toolConfig, targetMode);
-    return join11(this.projectDir, targetDir, skillName);
+    return join12(this.projectDir, targetDir, skillName);
   }
   isSkillDeployed(skillName, toolConfig, targetMode) {
     const skillPath = this.getDeployedSkillPath(skillName, toolConfig, targetMode);
     return existsSync3(skillPath);
   }
+  deployCommand(command, toolConfig, mode) {
+    const commandsDir = toolConfig.commandsDir;
+    if (!commandsDir) return;
+    const fullTargetDir = join12(this.projectDir, commandsDir);
+    ensureDir(fullTargetDir);
+    const commandTargetPath = join12(fullTargetDir, `${command.name}.md`);
+    if (mode === "link") {
+      linkFile(command.path, commandTargetPath);
+    } else {
+      copyFile(command.path, commandTargetPath);
+    }
+  }
+  deployCommands(commands, toolConfig, mode) {
+    for (const command of commands) {
+      this.deployCommand(command, toolConfig, mode);
+    }
+  }
+  removeCommand(commandName, toolConfig) {
+    const commandsDir = toolConfig.commandsDir;
+    if (!commandsDir) return;
+    const commandPath = join12(this.projectDir, commandsDir, `${commandName}.md`);
+    removeFile(commandPath);
+  }
+  getDeployedCommandPath(commandName, toolConfig) {
+    const commandsDir = toolConfig.commandsDir;
+    if (!commandsDir) return void 0;
+    return join12(this.projectDir, commandsDir, `${commandName}.md`);
+  }
+  isCommandDeployed(commandName, toolConfig) {
+    const commandPath = this.getDeployedCommandPath(commandName, toolConfig);
+    if (!commandPath) return false;
+    return existsSync3(commandPath);
+  }
 };
 
 // src/commands/init.ts
@@ -1692,11 +2169,13 @@ async function executeInit(options) {
     process.exit(1);
   }
   const skillsService = new SkillsService(SKILLS_MANAGER_DIR);
+  const commandsService = new CommandsService(SKILLS_MANAGER_DIR);
   const scanner = new DeploymentScanner(process.cwd(), SKILLS_MANAGER_DIR);
   const deployer = new Deployer(process.cwd());
   const allSkills = skillsService.getAllSkills();
-  if (allSkills.length === 0) {
-    console.log("No skills found. Run: skillsmgr install anthropic");
+  const allCommands = commandsService.getAllCommands();
+  if (allSkills.length === 0 && allCommands.length === 0) {
+    console.log("No skills or commands found. Run: skillsmgr install anthropic");
     process.exit(1);
   }
   const configuredTools = scanner.getConfiguredTools();
@@ -1716,75 +2195,123 @@ async function executeInit(options) {
     const deployed = scanner.getDeployedSkills(toolName);
     deployed.forEach((s) => deployedSkillNames.add(s.name));
   }
-  const selectedSkillNames = await promptSkills(
-    allSkills,
-    Array.from(deployedSkillNames)
+  let selectedSkillNames = [];
+  if (allSkills.length > 0) {
+    selectedSkillNames = await promptSkills(
+      allSkills,
+      Array.from(deployedSkillNames)
+    );
+  }
+  let selectedCommandNames = [];
+  const toolsWithCommands = selectedTools.filter(
+    (t) => TOOL_CONFIGS[t].commandsDir
   );
-  if (selectedSkillNames.length === 0) {
-    console.log("No skills selected");
+  if (allCommands.length > 0 && toolsWithCommands.length > 0) {
+    const deployedCommandNames = /* @__PURE__ */ new Set();
+    for (const toolName of selectedTools) {
+      const deployed = scanner.getDeployedCommands(toolName);
+      deployed.forEach((c) => deployedCommandNames.add(c.name));
+    }
+    selectedCommandNames = await promptCommands(
+      allCommands,
+      Array.from(deployedCommandNames)
+    );
+  }
+  if (selectedSkillNames.length === 0 && selectedCommandNames.length === 0) {
+    console.log("No skills or commands selected");
     return;
   }
   const selectedSkills = skillsService.getSkillsByNames(selectedSkillNames);
+  const selectedCommands = commandsService.getCommandsByNames(selectedCommandNames);
   const deployMode = options.copy ? "copy" : "link";
-  console.log("\nDeploying skills...\n");
+  console.log("\nDeploying...\n");
   for (const toolName of selectedTools) {
     const config = TOOL_CONFIGS[toolName];
     const mode = toolModes[toolName];
     const targetDir = getTargetDir(config, mode);
     console.log(`${config.displayName}:`);
-    const previouslyDeployed = scanner.getDeployedSkills(toolName);
-    const previousNames = new Set(previouslyDeployed.map((s) => s.name));
-    const toAdd = selectedSkills.filter((s) => !previousNames.has(s.name));
-    const toKeep = selectedSkills.filter((s) => previousNames.has(s.name));
-    const toRemove = previouslyDeployed.filter(
-      (s) => !selectedSkillNames.includes(s.name)
-    );
-    for (const skill of toRemove) {
-      deployer.removeSkill(skill.name, config, mode);
-      console.log(`  \u2717 ${skill.name} (removed)`);
-    }
-    for (const skill of toKeep) {
-      console.log(`  \xB7 ${skill.name} (unchanged)`);
+    if (selectedSkills.length > 0) {
+      const previouslyDeployed = scanner.getDeployedSkills(toolName);
+      const previousNames = new Set(previouslyDeployed.map((s) => s.name));
+      const toAdd = selectedSkills.filter((s) => !previousNames.has(s.name));
+      const toKeep = selectedSkills.filter((s) => previousNames.has(s.name));
+      const toRemove = previouslyDeployed.filter(
+        (s) => !selectedSkillNames.includes(s.name) && s.source !== "unknown"
+      );
+      const unmanagedSkills = previouslyDeployed.filter(
+        (s) => s.source === "unknown"
+      );
+      for (const skill of toRemove) {
+        deployer.removeSkill(skill.name, config, mode);
+        console.log(`  \u2717 ${skill.name} (removed)`);
+      }
+      for (const skill of toKeep) {
+        console.log(`  \xB7 ${skill.name} (unchanged)`);
+      }
+      for (const skill of toAdd) {
+        deployer.deploySkill(skill, config, deployMode, mode);
+        console.log(`  \u2713 ${skill.name} (${deployMode === "link" ? "linked" : "copied"})`);
+      }
+      for (const skill of unmanagedSkills) {
+        console.log(`  ~ ${skill.name} (unmanaged)`);
+      }
     }
-    for (const skill of toAdd) {
-      deployer.deploySkill(skill, config, deployMode, mode);
-      console.log(`  \u2713 ${skill.name} (${deployMode === "link" ? "linked" : "copied"})`);
+    if (config.commandsDir && selectedCommands.length > 0) {
+      const previouslyDeployed = scanner.getDeployedCommands(toolName);
+      const previousNames = new Set(previouslyDeployed.map((c) => c.name));
+      const toAdd = selectedCommands.filter((c) => !previousNames.has(c.name));
+      const toKeep = selectedCommands.filter((c) => previousNames.has(c.name));
+      const toRemove = previouslyDeployed.filter(
+        (c) => !selectedCommandNames.includes(c.name) && c.source !== "unknown"
+      );
+      const unmanagedCommands = previouslyDeployed.filter(
+        (c) => c.source === "unknown"
+      );
+      for (const cmd of toRemove) {
+        deployer.removeCommand(cmd.name, config);
+        console.log(`  \u2717 /${cmd.name} (removed)`);
+      }
+      for (const cmd of toKeep) {
+        console.log(`  \xB7 /${cmd.name} (unchanged)`);
+      }
+      for (const cmd of toAdd) {
+        deployer.deployCommand(cmd, config, deployMode);
+        console.log(`  \u2713 /${cmd.name} (${deployMode === "link" ? "linked" : "copied"})`);
+      }
+      for (const cmd of unmanagedCommands) {
+        console.log(`  ~ /${cmd.name} (unmanaged)`);
+      }
     }
     console.log();
   }
+  const parts = [];
+  if (selectedSkillNames.length > 0) parts.push(`${selectedSkillNames.length} skills`);
+  if (selectedCommandNames.length > 0) parts.push(`${selectedCommandNames.length} commands`);
   console.log(
-    `Done! Deployed ${selectedSkillNames.length} skills to ${selectedTools.length} tool${selectedTools.length > 1 ? "s" : ""}.`
+    `Done! Deployed ${parts.join(" and ")} to ${selectedTools.length} tool${selectedTools.length > 1 ? "s" : ""}.`
   );
 }
-var initCommand = new Command5("init").description("Deploy skills to current project").option("--copy", "Copy files instead of creating symlinks").action(async (options) => {
+var initCommand = new Command5("init").description("Deploy skills and commands to current project").option("--copy", "Copy files instead of creating symlinks").action(async (options) => {
   await executeInit(options);
 });
 
 // src/commands/add.ts
 import { Command as Command6 } from "commander";
-async function executeAdd(skillName, options) {
+async function executeAdd(name, options) {
   if (!fileExists(SKILLS_MANAGER_DIR)) {
     console.log("Skills manager not set up. Run: skillsmgr setup");
     process.exit(1);
   }
   const skillsService = new SkillsService(SKILLS_MANAGER_DIR);
+  const commandsService = new CommandsService(SKILLS_MANAGER_DIR);
   const scanner = new DeploymentScanner(process.cwd(), SKILLS_MANAGER_DIR);
   const deployer = new Deployer(process.cwd());
-  const matchingSkills = skillsService.findSkillsByName(skillName);
-  if (matchingSkills.length === 0) {
-    console.log(`Skill '${skillName}' not found`);
+  const matchingSkills = skillsService.findSkillsByName(name);
+  const matchingCommands = commandsService.findCommandsByName(name);
+  if (matchingSkills.length === 0 && matchingCommands.length === 0) {
+    console.log(`'${name}' not found as a skill or command`);
     process.exit(1);
   }
-  let skill = matchingSkills[0];
-  if (matchingSkills.length > 1) {
-    console.log(`Multiple skills found with name '${skillName}':`);
-    const choices = matchingSkills.map((s, i) => ({
-      name: `${i + 1}. ${s.source}/${s.name}`,
-      value: s.source
-    }));
-    const selectedSource = await promptSelect("Select skill:", choices);
-    skill = matchingSkills.find((s) => s.source === selectedSource);
-  }
   let targetTools;
   if (options.tool) {
     if (!TOOL_CONFIGS[options.tool]) {
@@ -1800,35 +2327,80 @@ async function executeAdd(skillName, options) {
     }
   }
   const deployMode = options.copy ? "copy" : "link";
-  console.log(`Adding ${skillName} to configured tools...`);
+  if (matchingSkills.length > 0) {
+    let skill = matchingSkills[0];
+    if (matchingSkills.length > 1) {
+      console.log(`Multiple skills found with name '${name}':`);
+      const choices = matchingSkills.map((s, i) => ({
+        name: `${i + 1}. ${s.source}/${s.name}`,
+        value: s.source
+      }));
+      const selectedSource = await promptSelect("Select skill:", choices);
+      skill = matchingSkills.find((s) => s.source === selectedSource);
+    }
+    console.log(`Adding skill ${name} to configured tools...`);
+    for (const toolName of targetTools) {
+      const config = TOOL_CONFIGS[toolName];
+      const deployments = scanner.scanToolDeployment(toolName, config);
+      const mode = deployments.length > 0 && deployments[0].mode ? deployments[0].mode : "all";
+      const existingSkills = scanner.getDeployedSkills(toolName);
+      const alreadyExists = existingSkills.some((s) => s.name === skill.name);
+      if (alreadyExists) {
+        console.log(`  \xB7 ${config.displayName} (already deployed)`);
+        continue;
+      }
+      deployer.deploySkill(skill, config, deployMode, mode);
+      console.log(
+        `  \u2713 ${config.displayName} (${deployMode === "link" ? "linked" : "copied"})`
+      );
+    }
+    return;
+  }
+  let command = matchingCommands[0];
+  if (matchingCommands.length > 1) {
+    console.log(`Multiple commands found with name '${name}':`);
+    const choices = matchingCommands.map((c, i) => ({
+      name: `${i + 1}. ${c.source}/${c.name}`,
+      value: c.source
+    }));
+    const selectedSource = await promptSelect("Select command:", choices);
+    command = matchingCommands.find((c) => c.source === selectedSource);
+  }
+  console.log(`Adding command /${name} to configured tools...`);
   for (const toolName of targetTools) {
     const config = TOOL_CONFIGS[toolName];
-    const deployments = scanner.scanToolDeployment(toolName, config);
-    const mode = deployments.length > 0 && deployments[0].mode ? deployments[0].mode : "all";
-    const existingSkills = scanner.getDeployedSkills(toolName);
-    const alreadyExists = existingSkills.some((s) => s.name === skill.name);
+    if (!config.commandsDir) {
+      console.log(`  \xB7 ${config.displayName} (commands not supported)`);
+      continue;
+    }
+    const existingCommands = scanner.getDeployedCommands(toolName);
+    const alreadyExists = existingCommands.some((c) => c.name === command.name);
     if (alreadyExists) {
       console.log(`  \xB7 ${config.displayName} (already deployed)`);
       continue;
     }
-    deployer.deploySkill(skill, config, deployMode, mode);
+    deployer.deployCommand(command, config, deployMode);
     console.log(
       `  \u2713 ${config.displayName} (${deployMode === "link" ? "linked" : "copied"})`
     );
   }
 }
-var addCommand = new Command6("add").description("Add a skill to the project").argument("<skill>", "Skill name to add").option("--tool <tool>", "Add to specific tool only").option("--copy", "Copy files instead of creating symlinks").action(async (skill, options) => {
-  await executeAdd(skill, options);
+var addCommand = new Command6("add").description("Add a skill or command to the project").argument("<name>", "Skill or command name to add").option("--tool <tool>", "Add to specific tool only").option("--copy", "Copy files instead of creating symlinks").action(async (name, options) => {
+  await executeAdd(name, options);
 });
 
 // src/commands/remove.ts
 import { Command as Command7 } from "commander";
-async function executeRemove(skillName, options) {
+async function executeRemove(name, options) {
+  if (!fileExists(SKILLS_MANAGER_DIR)) {
+    console.log("Skills manager not set up. Run: skillsmgr setup");
+    process.exit(1);
+  }
   const scanner = new DeploymentScanner(process.cwd(), SKILLS_MANAGER_DIR);
   const deployer = new Deployer(process.cwd());
   const configuredTools = scanner.getConfiguredTools();
   if (configuredTools.length === 0) {
-    console.log("No skills deployed in current project.");
+    console.log("No skills or commands deployed in current project.");
     process.exit(1);
   }
   let targetTools;
@@ -1841,41 +2413,55 @@ async function executeRemove(skillName, options) {
   } else {
     targetTools = configuredTools;
   }
-  console.log(`Removing ${skillName}...`);
+  console.log(`Removing ${name}...`);
   let removed = false;
   for (const toolName of targetTools) {
     const config = TOOL_CONFIGS[toolName];
     const deployments = scanner.scanToolDeployment(toolName, config);
     for (const deployment of deployments) {
-      const skillToRemove = deployment.skills.find((s) => s.name === skillName);
+      const skillToRemove = deployment.skills.find((s) => s.name === name);
       if (!skillToRemove) continue;
       const mode = deployment.mode || "all";
-      deployer.removeSkill(skillName, config, mode);
-      console.log(`  \u2713 Removed from ${config.displayName}`);
+      deployer.removeSkill(name, config, mode);
+      console.log(`  \u2713 Removed skill from ${config.displayName}`);
       removed = true;
     }
+    if (config.commandsDir) {
+      const deployedCommands = scanner.getDeployedCommands(toolName);
+      const commandToRemove = deployedCommands.find((c) => c.name === name);
+      if (commandToRemove) {
+        deployer.removeCommand(name, config);
+        console.log(`  \u2713 Removed command from ${config.displayName}`);
+        removed = true;
+      }
+    }
   }
   if (!removed) {
-    console.log(`Skill '${skillName}' not found in any configured tool`);
+    console.log(`'${name}' not found as a skill or command in any configured tool`);
   }
 }
-var removeCommand = new Command7("remove").description("Remove a skill from the project").argument("<skill>", "Skill name to remove").option("--tool <tool>", "Remove from specific tool only").action(async (skill, options) => {
-  await executeRemove(skill, options);
+var removeCommand = new Command7("remove").description("Remove a skill or command from the project").argument("<name>", "Skill or command name to remove").option("--tool <tool>", "Remove from specific tool only").action(async (name, options) => {
+  await executeRemove(name, options);
 });
 
 // src/commands/sync.ts
 import { Command as Command8 } from "commander";
-import { join as join12 } from "path";
+import { join as join13 } from "path";
 async function executeSync() {
+  if (!fileExists(SKILLS_MANAGER_DIR)) {
+    console.log("Skills manager not set up. Run: skillsmgr setup");
+    process.exit(1);
+  }
   const scanner = new DeploymentScanner(process.cwd(), SKILLS_MANAGER_DIR);
   const deployer = new Deployer(process.cwd());
   const skillsService = new SkillsService(SKILLS_MANAGER_DIR);
+  const commandsService = new CommandsService(SKILLS_MANAGER_DIR);
   const deployments = scanner.scanAllTools();
   if (deployments.length === 0) {
-    console.log("No skills deployed in current project.");
+    console.log("No skills or commands deployed in current project.");
     process.exit(1);
   }
-  console.log("Checking deployed skills...\n");
+  console.log("Checking deployed skills and commands...\n");
   let updatedCount = 0;
   let removedCount = 0;
   for (const deployment of deployments) {
@@ -1883,6 +2469,10 @@ async function executeSync() {
     const mode = deployment.mode || "all";
     console.log(`${config.displayName} (${deployment.targetDir}/):`);
     for (const skill of deployment.skills) {
+      if (skill.source === "unknown" && !skill.conflict) {
+        console.log(`  ~ ${skill.name} (unmanaged)`);
+        continue;
+      }
       if (skill.conflict) {
         console.log(`  \u26A0 ${skill.name}: conflict (skipped)`);
         continue;
@@ -1910,8 +2500,8 @@ async function executeSync() {
         continue;
       }
       if (skill.deployMode === "copy") {
-        const sourceSkillMd = join12(sourcePath, "SKILL.md");
-        const deployedSkillMd = join12(deployedPath, "SKILL.md");
+        const sourceSkillMd = join13(sourcePath, "SKILL.md");
+        const deployedSkillMd = join13(deployedPath, "SKILL.md");
         if (fileExists(sourceSkillMd) && fileExists(deployedSkillMd)) {
           const sourceContent = readFileContent(sourceSkillMd);
           const deployedContent = readFileContent(deployedSkillMd);
@@ -1951,19 +2541,62 @@ async function executeSync() {
         }
       }
     }
+    for (const command of deployment.commands) {
+      if (command.source === "unknown") {
+        console.log(`  ~ /${command.name} (unmanaged)`);
+        continue;
+      }
+      const deployedPath = command.path;
+      let sourceCommand = commandsService.getCommandByName(command.name);
+      if (!sourceCommand || !fileExists(sourceCommand.path)) {
+        console.log(`  \u2717 /${command.name}: orphaned (source not found)`);
+        const action = await promptOrphanAction(command.name);
+        if (action === "remove") {
+          deployer.removeCommand(command.name, config);
+          console.log(`  \u2713 Removed /${command.name}`);
+          removedCount++;
+        }
+        continue;
+      }
+      if (isSymlink(deployedPath)) {
+        console.log(`  \u2713 /${command.name}: up to date (link)`);
+        continue;
+      }
+      if (command.deployMode === "copy") {
+        const sourceContent = readFileContent(sourceCommand.path);
+        const deployedContent = readFileContent(deployedPath);
+        if (sourceContent !== deployedContent) {
+          console.log(`  \u26A0 /${command.name}: source changed (copy)`);
+          const action = await promptSyncAction(command.name, false);
+          if (action === "overwrite") {
+            deployer.deployCommand(
+              { name: command.name, description: "", path: sourceCommand.path, source: command.source },
+              config,
+              "copy"
+            );
+            console.log(`  \u2713 Updated /${command.name}`);
+            updatedCount++;
+          }
+        } else {
+          console.log(`  \u2713 /${command.name}: up to date (copy)`);
+        }
+      }
+    }
     console.log();
   }
   console.log(
     `Sync complete: ${updatedCount} updated, ${removedCount} removed`
   );
 }
-var syncCommand = new Command8("sync").description("Sync and verify deployed skills").action(async () => {
+var syncCommand = new Command8("sync").description("Sync and verify deployed skills and commands").action(async () => {
   await executeSync();
 });
 
 // src/index.ts
+var require2 = createRequire(import.meta.url);
+var { version } = require2("../package.json");
 var program = new Command9();
-program.name("skillsmgr").description("Unified skills manager for AI coding tools").version("0.1.0");
+program.name("skillsmgr").description("Unified skills manager for AI coding tools").version(version);
 program.addCommand(setupCommand);
 program.addCommand(installCommand);
 program.addCommand(updateCommand);