agentsmesh 0.2.1 → 0.2.2

package/CHANGELOG.md

@@ -1,5 +1,11 @@
 # Changelog
 
+## 0.2.2
+
+### Patch Changes
+
+- d42b374: Support installing standalone skill repos (bare GitHub/GitLab URLs), use SKILL.md frontmatter name for skill identity, filter repo boilerplate from installed skills, and fix pack skill reference paths in generated output.
+
 All notable changes to this project will be documented in this file.
 
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),

package/README.md

@@ -2,7 +2,7 @@
 
 [![CI](https://github.com/sampleXbro/agentsmesh/actions/workflows/ci.yml/badge.svg)](https://github.com/sampleXbro/agentsmesh/actions/workflows/ci.yml)
 [![npm version](https://img.shields.io/npm/v/agentsmesh.svg)](https://www.npmjs.com/package/agentsmesh)
-[![Coverage](https://codecov.io/gh/sampleXbro/agentsmesh/branch/main/graph/badge.svg)](https://codecov.io/gh/sampleXbro/agentsmesh)
+[![Coverage](https://codecov.io/gh/sampleXbro/agentsmesh/branch/master/graph/badge.svg)](https://codecov.io/gh/sampleXbro/agentsmesh)
 [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](LICENSE)
 [![TypeScript](https://img.shields.io/badge/TypeScript-strict-blue.svg)](https://www.typescriptlang.org/)
 [![Node.js](https://img.shields.io/node/v/agentsmesh.svg)](https://nodejs.org/)

package/dist/cli.js

@@ -5455,6 +5455,10 @@ async function readContent(path) {
   return c2 ?? "";
 }
 var SKILL_FILE = "SKILL.md";
+var EXCLUDED_DIR_PREFIXES = [".git", "node_modules"];
+function sanitizeSkillName(raw) {
+  return raw.toLowerCase().replace(/[^a-z0-9-]+/g, "-").replace(/-+/g, "-").replace(/^-|-$/g, "");
+}
 async function listSupportingFiles(skillDir) {
   const files = await readDirRecursive(skillDir);
   const result = [];
@@ -5462,6 +5466,9 @@ async function listSupportingFiles(skillDir) {
     const raw = absPath.slice(skillDir.length + 1);
     const name = raw.replace(/\\/g, "/");
     if (name === SKILL_FILE || name.endsWith(`/${SKILL_FILE}`)) continue;
+    const firstSegment = name.split("/")[0];
+    if (EXCLUDED_DIR_PREFIXES.some((p) => firstSegment === p)) continue;
+    if (name === ".DS_Store" || name.endsWith("/.DS_Store")) continue;
     const content = await readContent(absPath);
     result.push({ relativePath: name, absolutePath: absPath, content });
   }
@@ -5473,9 +5480,10 @@ async function parseSkillDirectory(skillDir) {
   if (!content) return null;
   const { frontmatter, body } = parseFrontmatter(content);
   const supportingFiles = await listSupportingFiles(skillDir);
+  const fmName = typeof frontmatter.name === "string" ? sanitizeSkillName(frontmatter.name) : "";
   return {
     source: skillPath,
-    name: basename25(skillDir),
+    name: fmName || basename25(skillDir),
     description: typeof frontmatter.description === "string" ? frontmatter.description : "",
     body,
     supportingFiles
@@ -7976,10 +7984,10 @@ function preferEquivalentCodexAgents(results, canonical, config) {
 
 // src/core/reference-rewriter.ts
 import { existsSync as existsSync3 } from "fs";
-import { dirname as dirname19, join as join48 } from "path";
+import { dirname as dirname20, join as join48 } from "path";
 
 // src/core/output-source-map.ts
-import { join as join47, normalize as normalizePath2 } from "path";
+import { dirname as dirname19, join as join47, normalize as normalizePath2 } from "path";
 function canonicalRulePath(rule) {
   return `.agentsmesh/rules/${rule.source.split("/").pop()}`;
 }
@@ -8025,6 +8033,22 @@ function ruleOutputPaths(target10, rule, refs) {
   }
   return paths;
 }
+function addPackSkillPaths(refs, target10, canonical, projectRoot) {
+  const skillDir = SKILL_DIRS[target10];
+  if (!skillDir) return;
+  const packsPrefix = join47(projectRoot, ".agentsmesh", "packs");
+  for (const skill of canonical.skills) {
+    const skillSourceDir = dirname19(skill.source);
+    if (!skillSourceDir.startsWith(packsPrefix)) continue;
+    const targetSkillDir = normalizePath2(join47(projectRoot, skillDir, skill.name));
+    refs.set(normalizePath2(skillSourceDir), targetSkillDir);
+    refs.set(normalizePath2(skill.source), normalizePath2(join47(targetSkillDir, "SKILL.md")));
+    for (const file of skill.supportingFiles) {
+      const targetFilePath = normalizePath2(join47(targetSkillDir, file.relativePath));
+      refs.set(normalizePath2(file.absolutePath), targetFilePath);
+    }
+  }
+}
 function buildArtifactPathMap(target10, canonical, config, projectRoot, destinationPath) {
   const refs = new Map(
     [...buildReferenceMap(target10, canonical, config)].map(([canonicalPath, targetPath]) => [
@@ -8041,6 +8065,7 @@ function buildArtifactPathMap(target10, canonical, config, projectRoot, destinat
       );
     }
   }
+  addPackSkillPaths(refs, target10, canonical, projectRoot);
   return refs;
 }
 function buildOutputSourceMap(target10, canonical, config) {
@@ -8077,11 +8102,11 @@ function collectPlannedPaths(projectRoot, results) {
   for (const result of results) {
     const absolutePath = join48(projectRoot, result.path);
     planned.add(absolutePath);
-    let current = dirname19(absolutePath);
+    let current = dirname20(absolutePath);
     while (current.startsWith(projectRoot) && !planned.has(current)) {
       planned.add(current);
       if (current === projectRoot) break;
-      current = dirname19(current);
+      current = dirname20(current);
     }
   }
   return planned;
@@ -9580,7 +9605,7 @@ async function runCheck(flags, projectRoot) {
 import { join as join58 } from "path";
 
 // src/core/merger.ts
-import { dirname as dirname20, join as join57 } from "path";
+import { dirname as dirname21, join as join57 } from "path";
 var LOCK_FILENAME2 = ".lock";
 var CONFLICT_MARKER = "<<<<<<<";
 async function hasLockConflict(abDir) {
@@ -9595,7 +9620,7 @@ async function resolveLockConflict(abDir, libVersion, config) {
     throw new Error("No conflict to resolve.");
   }
   const checksums = await buildChecksums(abDir);
-  const configDir = dirname20(abDir);
+  const configDir = dirname21(abDir);
   const resolvedExtends = config ? await resolveExtendPaths(config, configDir) : [];
   const extendChecksums = resolvedExtends.length > 0 ? await buildExtendChecksums(resolvedExtends) : {};
   const packChecksums = await buildPackChecksums(join57(abDir, "packs"));
@@ -9626,7 +9651,7 @@ async function runMerge(flags, projectRoot) {
 }
 
 // src/install/run-install.ts
-import { join as join71 } from "path";
+import { join as join72 } from "path";
 
 // src/install/git-pin.ts
 import { execFile as execFile2 } from "child_process";
@@ -10001,6 +10026,50 @@ function parseGitlabBlobUrl(urlStr) {
     return null;
   }
 }
+var GITHUB_ROUTE_WORDS = /* @__PURE__ */ new Set([
+  "tree",
+  "blob",
+  "commit",
+  "releases",
+  "actions",
+  "issues",
+  "pulls",
+  "settings",
+  "wiki",
+  "discussions",
+  "security",
+  "projects",
+  "packages"
+]);
+function parseGithubRepoUrl(urlStr) {
+  try {
+    const u = new URL3(urlStr);
+    if (u.hostname !== "github.com") return null;
+    const parts = u.pathname.split("/").filter(Boolean).map((s) => s.replace(/\.git$/i, ""));
+    if (parts.length < 2) return null;
+    if (parts.length > 2 || GITHUB_ROUTE_WORDS.has(parts[1])) return null;
+    const org = parts[0];
+    const repo = parts[1];
+    return { org, repo };
+  } catch {
+    return null;
+  }
+}
+function parseGitlabRepoUrl(urlStr) {
+  try {
+    const u = new URL3(urlStr);
+    if (u.hostname !== "gitlab.com") return null;
+    const parts = u.pathname.split("/").filter(Boolean).map((s) => s.replace(/\.git$/i, ""));
+    if (parts.length < 2) return null;
+    if (parts.includes("-")) return null;
+    const project = parts[parts.length - 1];
+    const namespace = parts.slice(0, -1).join("/");
+    if (!namespace || !project) return null;
+    return { namespace, project };
+  } catch {
+    return null;
+  }
+}
 function parseGitSshGithub(ssh) {
   const m = ssh.match(/^git@github\.com:([^/]+)\/(.+?)(?:\.git)?$/i);
   if (!m) return null;
@@ -10038,26 +10107,48 @@ async function parseInstallSource(raw, configDir, explicitPath) {
     };
   }
   if (trimmed.startsWith("https://") || trimmed.startsWith("http://")) {
-    const gh = parseGithubTreeUrl(trimmed) ?? parseGithubBlobUrl(trimmed);
-    if (gh) {
+    const ghDetailed = parseGithubTreeUrl(trimmed) ?? parseGithubBlobUrl(trimmed);
+    if (ghDetailed) {
+      return {
+        kind: "github",
+        rawRef: ghDetailed.ref,
+        org: ghDetailed.org,
+        repo: ghDetailed.repo,
+        gitRemoteUrl: `https://github.com/${ghDetailed.org}/${ghDetailed.repo}.git`,
+        pathInRepo: pathFlag || ghDetailed.path
+      };
+    }
+    const ghBare = parseGithubRepoUrl(trimmed);
+    if (ghBare) {
       return {
         kind: "github",
-        rawRef: gh.ref,
-        org: gh.org,
-        repo: gh.repo,
-        gitRemoteUrl: `https://github.com/${gh.org}/${gh.repo}.git`,
-        pathInRepo: pathFlag || gh.path
+        rawRef: "HEAD",
+        org: ghBare.org,
+        repo: ghBare.repo,
+        gitRemoteUrl: `https://github.com/${ghBare.org}/${ghBare.repo}.git`,
+        pathInRepo: pathFlag
       };
     }
-    const gl = parseGitlabTreeUrl(trimmed) ?? parseGitlabBlobUrl(trimmed);
-    if (gl) {
+    const glDetailed = parseGitlabTreeUrl(trimmed) ?? parseGitlabBlobUrl(trimmed);
+    if (glDetailed) {
       return {
         kind: "gitlab",
-        rawRef: gl.ref,
-        org: gl.namespace,
-        repo: gl.project,
-        gitRemoteUrl: `https://gitlab.com/${gl.namespace}/${gl.project}.git`,
-        pathInRepo: pathFlag || gl.path
+        rawRef: glDetailed.ref,
+        org: glDetailed.namespace,
+        repo: glDetailed.project,
+        gitRemoteUrl: `https://gitlab.com/${glDetailed.namespace}/${glDetailed.project}.git`,
+        pathInRepo: pathFlag || glDetailed.path
+      };
+    }
+    const glBare = parseGitlabRepoUrl(trimmed);
+    if (glBare) {
+      return {
+        kind: "gitlab",
+        rawRef: "HEAD",
+        org: glBare.namespace,
+        repo: glBare.project,
+        gitRemoteUrl: `https://gitlab.com/${glBare.namespace}/${glBare.project}.git`,
+        pathInRepo: pathFlag
       };
     }
   }
@@ -10324,7 +10415,7 @@ import { join as join63 } from "path";
 import { rename as rename4 } from "fs/promises";
 
 // src/install/pack-writer.ts
-import { join as join60, basename as basename39, dirname as dirname21 } from "path";
+import { join as join60, basename as basename39, dirname as dirname22 } from "path";
 import { rm as rm6, rename as rename3, mkdir as mkdir5, copyFile as copyFile2 } from "fs/promises";
 import { stringify as yamlStringify6 } from "yaml";
 
@@ -10385,7 +10476,7 @@ async function writeSkills(canonical, packDir) {
     await copyFile2(skill.source, join60(skillDestDir, "SKILL.md"));
     for (const sf of skill.supportingFiles) {
       const destPath = join60(skillDestDir, sf.relativePath);
-      await mkdirp(dirname21(destPath));
+      await mkdirp(dirname22(destPath));
       await copyFile2(sf.absolutePath, destPath);
     }
   }
@@ -10430,7 +10521,7 @@ async function materializePack(packsDir, packName, canonical, metadataInput) {
 }
 
 // src/install/pack-merge.ts
-import { join as join61, basename as basename40, dirname as dirname22 } from "path";
+import { join as join61, basename as basename40, dirname as dirname23 } from "path";
 import { copyFile as copyFile3 } from "fs/promises";
 import { stringify as yamlStringify7 } from "yaml";
 function union(a, b) {
@@ -10493,7 +10584,7 @@ async function mergeSkills(canonical, packDir) {
     await copyFile3(skill.source, join61(destDir, "SKILL.md"));
     for (const sf of skill.supportingFiles) {
       const destPath = join61(destDir, sf.relativePath);
-      await mkdirp(dirname22(destPath));
+      await mkdirp(dirname23(destPath));
       await copyFile3(sf.absolutePath, destPath);
     }
   }
@@ -10919,9 +11010,66 @@ function narrowDiscoveredForInstallScope(canonical, options) {
 }
 
 // src/install/manual-install-scope.ts
-import { basename as basename41, dirname as dirname23, join as join65, relative as relative21 } from "path";
-import { cp, mkdtemp, stat as stat5, rm as rm7 } from "fs/promises";
+import { basename as basename41, dirname as dirname24, join as join65, relative as relative22 } from "path";
+import { cp as cp2, mkdtemp, stat as stat5, rm as rm7 } from "fs/promises";
 import { tmpdir } from "os";
+
+// src/install/skill-repo-filter.ts
+import { relative as relative21 } from "path";
+import { cp } from "fs/promises";
+init_markdown();
+var REPO_BOILERPLATE_FILES = /* @__PURE__ */ new Set([
+  "README.md",
+  "README.rst",
+  "README.txt",
+  "README",
+  "LICENSE",
+  "LICENSE.md",
+  "LICENSE.txt",
+  "LICENSE-MIT",
+  "LICENSE-APACHE",
+  "CONTRIBUTING.md",
+  "CHANGELOG.md",
+  "CODE_OF_CONDUCT.md",
+  "package.json",
+  "package-lock.json",
+  "pnpm-lock.yaml",
+  "yarn.lock",
+  ".gitignore",
+  ".gitattributes",
+  ".editorconfig",
+  ".DS_Store"
+]);
+var REPO_BOILERPLATE_DIRS = /* @__PURE__ */ new Set([
+  ".git",
+  ".github",
+  ".gitlab",
+  "node_modules",
+  ".vscode",
+  ".idea"
+]);
+async function readSkillFrontmatterName(skillMdPath) {
+  const content = await readFileSafe(skillMdPath);
+  if (!content) return "";
+  const { frontmatter } = parseFrontmatter(content);
+  if (typeof frontmatter.name !== "string") return "";
+  return frontmatter.name.toLowerCase().replace(/[^a-z0-9-]+/g, "-").replace(/-+/g, "-").replace(/^-|-$/g, "");
+}
+async function cpFilteredSkill(sourceRoot, destDir) {
+  await cp(sourceRoot, destDir, {
+    recursive: true,
+    filter: (src) => {
+      const rel2 = relative21(sourceRoot, src).replace(/\\/g, "/");
+      if (rel2 === "") return true;
+      const first = rel2.split("/")[0];
+      if (REPO_BOILERPLATE_DIRS.has(first)) return false;
+      if (!rel2.includes("/") && REPO_BOILERPLATE_FILES.has(rel2)) return false;
+      return true;
+    }
+  });
+}
+
+// src/install/manual-install-scope.ts
 async function createStageRoot() {
   const stageBase = await mkdtemp(join65(tmpdir(), "am-install-manual-"));
   const discoveryRoot = join65(stageBase, "repo");
@@ -10940,7 +11088,7 @@ async function stageMarkdownCollection(sourceRoot, destinationDir) {
       throw new Error(`Manual install only supports .md files for this collection: ${sourceRoot}`);
     }
     await mkdirp(destinationDir);
-    await cp(sourceRoot, join65(destinationDir, basename41(sourceRoot)));
+    await cp2(sourceRoot, join65(destinationDir, basename41(sourceRoot)));
     return;
   }
   const files = (await readDirRecursive(sourceRoot)).filter(
@@ -10960,7 +11108,7 @@ async function stageMarkdownCollection(sourceRoot, destinationDir) {
       );
     }
     usedNames.set(name, file);
-    await cp(file, join65(destinationDir, name));
+    await cp2(file, join65(destinationDir, name));
   }
 }
 async function stagePreferredSkills(sourceRoot, destinationDir, preferredSkillNames) {
@@ -10971,7 +11119,7 @@ async function stagePreferredSkills(sourceRoot, destinationDir, preferredSkillNa
   const matches = /* @__PURE__ */ new Map();
   for (const file of await readDirRecursive(sourceRoot)) {
     if (!file.endsWith("/SKILL.md") && !file.endsWith("\\SKILL.md")) continue;
-    const skillDir = dirname23(file);
+    const skillDir = dirname24(file);
     const skillName = basename41(skillDir);
     if (!wanted.has(skillName)) continue;
     const previous = matches.get(skillName);
@@ -10985,7 +11133,7 @@ async function stagePreferredSkills(sourceRoot, destinationDir, preferredSkillNa
   if (matches.size !== preferredSkillNames.length) return false;
   await mkdirp(destinationDir);
   for (const skillName of preferredSkillNames) {
-    await cp(matches.get(skillName), join65(destinationDir, skillName), { recursive: true });
+    await cp2(matches.get(skillName), join65(destinationDir, skillName), { recursive: true });
   }
   return true;
 }
@@ -10995,10 +11143,10 @@ async function stageSkills(sourceRoot, destinationDir, options = {}) {
     if (basename41(sourceRoot) !== "SKILL.md") {
       throw new Error(`Manual skill install expects SKILL.md or a skill directory: ${sourceRoot}`);
     }
-    const skillName = basename41(dirname23(sourceRoot));
+    const skillName = basename41(dirname24(sourceRoot));
     const skillDir = join65(destinationDir, skillName);
     await mkdirp(skillDir);
-    await cp(dirname23(sourceRoot), skillDir, { recursive: true });
+    await cp2(dirname24(sourceRoot), skillDir, { recursive: true });
     return;
   }
   if (await isSkillPackLayout(sourceRoot)) {
@@ -11006,9 +11154,11 @@ async function stageSkills(sourceRoot, destinationDir, options = {}) {
       if (await stagePreferredSkills(sourceRoot, destinationDir, options.preferredSkillNames ?? [])) {
         return;
       }
-      const skillDir = join65(destinationDir, basename41(sourceRoot));
+      const fmName = await readSkillFrontmatterName(join65(sourceRoot, "SKILL.md"));
+      const skillName = fmName || basename41(sourceRoot);
+      const skillDir = join65(destinationDir, skillName);
       await mkdirp(destinationDir);
-      await cp(sourceRoot, skillDir, { recursive: true });
+      await cpFilteredSkill(sourceRoot, skillDir);
       return;
     }
     if (await stagePreferredSkills(sourceRoot, destinationDir, options.preferredSkillNames ?? [])) {
@@ -11020,10 +11170,10 @@ async function stageSkills(sourceRoot, destinationDir, options = {}) {
     for (const file of entries.filter(
       (entry) => entry.endsWith("/SKILL.md") || entry.endsWith("\\SKILL.md")
     )) {
-      roots.add(relative21(sourceRoot, dirname23(file)).split(/[\\/]/)[0]);
+      roots.add(relative22(sourceRoot, dirname24(file)).split(/[\\/]/)[0]);
     }
     for (const root of roots) {
-      await cp(join65(sourceRoot, root), join65(destinationDir, root), { recursive: true });
+      await cp2(join65(sourceRoot, root), join65(destinationDir, root), { recursive: true });
     }
     return;
   }
@@ -11132,7 +11282,7 @@ function extendPickHasArrays(p) {
 import { basename as basename44, join as join68 } from "path";
 
 // src/install/gemini-install-commands.ts
-import { join as join66, relative as relative22 } from "path";
+import { join as join66, relative as relative23 } from "path";
 async function inferGeminiCommandNamesFromFiles(repoRoot, pathInRepoPosix) {
   const commandsRoot = join66(repoRoot, ...GEMINI_COMMANDS_DIR.split("/"));
   const scanDir = join66(repoRoot, ...pathInRepoPosix.split("/"));
@@ -11140,7 +11290,7 @@ async function inferGeminiCommandNamesFromFiles(repoRoot, pathInRepoPosix) {
   const names = [];
   for (const f of files) {
     if (!/\.(toml|md)$/i.test(f)) continue;
-    const rel2 = relative22(commandsRoot, f).replace(/\\/g, "/");
+    const rel2 = relative23(commandsRoot, f).replace(/\\/g, "/");
     if (rel2.startsWith("..") || rel2 === "") continue;
     const noExt = rel2.replace(/\.(toml|md)$/i, "");
     const name = noExt.split("/").filter(Boolean).join(":");
@@ -11150,16 +11300,16 @@ async function inferGeminiCommandNamesFromFiles(repoRoot, pathInRepoPosix) {
 }
 
 // src/install/native-skill-scan.ts
-import { basename as basename42, dirname as dirname24, relative as relative23 } from "path";
+import { basename as basename42, dirname as dirname25, relative as relative24 } from "path";
 async function skillNamesFromNativeSkillDir(scanRoot) {
   const files = await readDirRecursive(scanRoot);
   const names = /* @__PURE__ */ new Set();
   for (const f of files) {
     if (basename42(f) === "SKILL.md") {
-      names.add(basename42(dirname24(f)));
+      names.add(basename42(dirname25(f)));
       continue;
     }
-    const rel2 = relative23(scanRoot, f).replace(/\\/g, "/");
+    const rel2 = relative24(scanRoot, f).replace(/\\/g, "/");
     if (!rel2.includes("/") && f.toLowerCase().endsWith(".md")) {
       names.add(basename42(f, ".md"));
     }
@@ -11342,8 +11492,8 @@ function isImplicitPickEmpty(p) {
 }
 
 // src/install/native-install-scope.ts
-import { basename as basename45, join as join69, relative as relative24 } from "path";
-import { cp as cp2, mkdtemp as mkdtemp2, rm as rm8 } from "fs/promises";
+import { basename as basename45, join as join69, relative as relative25 } from "path";
+import { cp as cp3, mkdtemp as mkdtemp2, rm as rm8 } from "fs/promises";
 import { tmpdir as tmpdir2 } from "os";
 function normalizePath3(path) {
   return path.replace(/\\/g, "/").replace(/\/+$/, "");
@@ -11365,7 +11515,7 @@ async function makeStageRoot(repoRoot) {
     await rm8(stageBase, { recursive: true, force: true });
   };
   try {
-    await cp2(repoRoot, stageRoot, { recursive: true });
+    await cp3(repoRoot, stageRoot, { recursive: true });
     return { stageRoot, cleanup };
   } catch (error) {
     await cleanup();
@@ -11398,7 +11548,7 @@ function buildPickFromResults(results, stageRoot) {
     }
     if (result.feature === "skills" && result.toPath.startsWith(".agentsmesh/skills/")) {
       const rel2 = normalizePath3(
-        relative24(join69(stageRoot, ".agentsmesh", "skills"), join69(stageRoot, result.toPath))
+        relative25(join69(stageRoot, ".agentsmesh", "skills"), join69(stageRoot, result.toPath))
       );
       const skillName = rel2.split("/")[0];
       if (skillName) {
@@ -11586,7 +11736,7 @@ function applyReplayInstallScope(narrowed, discoveredFeatures, replay) {
 }
 
 // src/install/manual-install-persistence.ts
-import { basename as basename46, dirname as dirname25 } from "path";
+import { basename as basename46, dirname as dirname26, join as join71 } from "path";
 import { stat as stat6 } from "fs/promises";
 function trimDot(pathInRepo) {
   return pathInRepo === "." || pathInRepo === "" ? void 0 : pathInRepo;
@@ -11605,27 +11755,28 @@ async function resolveManualInstallPersistence(args) {
   const info = await stat6(args.contentRoot);
   if (args.as !== "skills" && info.isFile() && args.contentRoot.toLowerCase().endsWith(".md")) {
     return {
-      pathInRepo: trimDot(dirname25(normalizedPath)),
+      pathInRepo: trimDot(dirname26(normalizedPath)),
       pick: markdownPick(args.as, normalizedPath || args.contentRoot)
     };
   }
   if (args.as === "skills") {
     if (info.isFile() && basename46(args.contentRoot) === "SKILL.md") {
-      const skillDir = normalizedPath ? dirname25(normalizedPath) : dirname25(args.contentRoot);
+      const skillDir = normalizedPath ? dirname26(normalizedPath) : dirname26(args.contentRoot);
       return {
-        pathInRepo: trimDot(dirname25(skillDir)),
+        pathInRepo: trimDot(dirname26(skillDir)),
         pick: { skills: [basename46(skillDir)] }
       };
     }
     if (info.isDirectory()) {
       const skillDir = normalizedPath || basename46(args.contentRoot);
-      const skillFile = `${args.contentRoot.replace(/\/+$/g, "")}/SKILL.md`;
+      const skillFile = join71(args.contentRoot.replace(/\/+$/g, ""), "SKILL.md");
       try {
         const skillStat = await stat6(skillFile);
         if (skillStat.isFile()) {
+          const fmName = await readSkillFrontmatterName(skillFile);
           return {
-            pathInRepo: trimDot(dirname25(skillDir)),
-            pick: { skills: [basename46(skillDir)] }
+            pathInRepo: trimDot(dirname26(skillDir)),
+            pick: { skills: [fmName || basename46(skillDir)] }
           };
         }
       } catch {
@@ -11693,7 +11844,7 @@ async function runInstall(flags, args, projectRoot, replay) {
     sourceArg
   );
   const pathInRepo = parsed.pathInRepo.replace(/^\/+|\/+$/g, "");
-  const contentRoot = pathInRepo ? join71(resolvedPath, pathInRepo) : resolvedPath;
+  const contentRoot = pathInRepo ? join72(resolvedPath, pathInRepo) : resolvedPath;
   if (!await exists(contentRoot)) {
     throw new Error(`Install path does not exist: ${contentRoot}`);
   }