playbooks 0.1.7 → 0.1.9

package/README.md

@@ -39,7 +39,7 @@ Skills let your agents perform specialized tasks like:
 
 ## Usage
 
-Playbooks uses an action/type command structure:
+playbooks uses an action/type command structure:
 - `npx playbooks add skill <source>`
 - `npx playbooks find skill`
 - `npx playbooks list skill`
@@ -94,6 +94,12 @@ npx playbooks add skill git@github.com:anthropics/skills.git
 npx playbooks add skill https://docs.example.com/skills/my-skill/SKILL.md
 ```
 
+- Docs URL (well-known skills discovery)
+```bash
+npx playbooks add skill https://mintlify.com/docs
+npx playbooks add skill mintlify.com/docs
+```
+
 - Marketplace.json (path)
 ```bash
 npx playbooks add skill ./path/to/.claude-plugin/marketplace.json
@@ -109,6 +115,36 @@ npx playbooks add skill https://raw.githubusercontent.com/org/repo/main/.claude-
 npx playbooks add skill org/repo/.claude-plugin/marketplace.json
 ```
 
+### Well-known skills discovery (RFC 8615)
+
+If a docs site publishes a skills index at a predictable path, playbooks can discover and install skills from the site URL directly. The CLI looks for:
+
+```text
+https://example.com/docs/.well-known/skills/index.json
+```
+
+The index lists one or more skills and the files for each skill:
+
+```json
+{
+  "skills": [
+    {
+      "name": "mintlify",
+      "description": "Build and maintain documentation sites with Mintlify.",
+      "files": ["SKILL.md"]
+    }
+  ]
+}
+```
+
+When you run `npx playbooks add skill <docs-url>`, playbooks fetches the index and then downloads each skill from:
+
+```text
+https://example.com/docs/.well-known/skills/<skill-name>/SKILL.md
+```
+
+Multiple skills can be listed in the same index and will be shown in the selection screen.
+
 ### Options (add skill)
 
 | Option                    | Description                                                                                                                                        |
@@ -167,7 +203,7 @@ npx playbooks manage skill
 
 ## Marketplace.json support
 
-Playbooks can ingest a Claude-style `marketplace.json` and pull skills from the plugins it lists.
+playbooks can ingest a Claude-style `marketplace.json` and pull skills from the plugins it lists.
 
 What it scans:
 - The plugin root (if it contains `SKILL.md`)

package/dist/index.js

@@ -8,7 +8,7 @@ import { program } from "commander";
 // package.json
 var package_default = {
   name: "playbooks",
-  version: "0.1.7",
+  version: "0.1.9",
   description: "Install agent skills, MCPs and docs into your coding agents from any git repository.",
   type: "module",
   bin: {
@@ -1759,8 +1759,9 @@ function isDirectSkillUrl(input) {
   return true;
 }
 function parseSource(input) {
-  if (isLocalPath(input)) {
-    const resolvedPath = resolve4(input);
+  let normalizedInput = input;
+  if (isLocalPath(normalizedInput)) {
+    const resolvedPath = resolve4(normalizedInput);
     return {
       type: "local",
       url: resolvedPath,
@@ -1768,13 +1769,18 @@ function parseSource(input) {
       localPath: resolvedPath
     };
   }
-  if (isDirectSkillUrl(input)) {
+  if (shouldPrefixHttps(normalizedInput)) {
+    normalizedInput = `https://${normalizedInput}`;
+  }
+  if (isDirectSkillUrl(normalizedInput)) {
     return {
       type: "direct-url",
-      url: input
+      url: normalizedInput
     };
   }
-  const githubTreeWithPathMatch = input.match(/github\.com\/([^/]+)\/([^/]+)\/tree\/([^/]+)\/(.+)/);
+  const githubTreeWithPathMatch = normalizedInput.match(
+    /github\.com\/([^/]+)\/([^/]+)\/tree\/([^/]+)\/(.+)/
+  );
   if (githubTreeWithPathMatch) {
     const [, owner, repo, ref, subpath] = githubTreeWithPathMatch;
     return {
@@ -1784,7 +1790,7 @@ function parseSource(input) {
       subpath
     };
   }
-  const githubTreeMatch = input.match(/github\.com\/([^/]+)\/([^/]+)\/tree\/([^/]+)$/);
+  const githubTreeMatch = normalizedInput.match(/github\.com\/([^/]+)\/([^/]+)\/tree\/([^/]+)$/);
   if (githubTreeMatch) {
     const [, owner, repo, ref] = githubTreeMatch;
     return {
@@ -1793,7 +1799,7 @@ function parseSource(input) {
       ref
     };
   }
-  const githubRepoMatch = input.match(/github\.com\/([^/]+)\/([^/]+)/);
+  const githubRepoMatch = normalizedInput.match(/github\.com\/([^/]+)\/([^/]+)/);
   if (githubRepoMatch) {
     const [, owner, repo] = githubRepoMatch;
     const cleanRepo = repo?.replace(/\.git$/, "");
@@ -1802,7 +1808,7 @@ function parseSource(input) {
       url: `https://github.com/${owner}/${cleanRepo}.git`
     };
   }
-  const gitlabTreeWithPathMatch = input.match(
+  const gitlabTreeWithPathMatch = normalizedInput.match(
     /gitlab\.com\/([^/]+)\/([^/]+)\/-\/tree\/([^/]+)\/(.+)/
   );
   if (gitlabTreeWithPathMatch) {
@@ -1814,7 +1820,7 @@ function parseSource(input) {
       subpath
     };
   }
-  const gitlabTreeMatch = input.match(/gitlab\.com\/([^/]+)\/([^/]+)\/-\/tree\/([^/]+)$/);
+  const gitlabTreeMatch = normalizedInput.match(/gitlab\.com\/([^/]+)\/([^/]+)\/-\/tree\/([^/]+)$/);
   if (gitlabTreeMatch) {
     const [, owner, repo, ref] = gitlabTreeMatch;
     return {
@@ -1823,7 +1829,7 @@ function parseSource(input) {
       ref
     };
   }
-  const gitlabRepoMatch = input.match(/gitlab\.com\/([^/]+)\/([^/]+)/);
+  const gitlabRepoMatch = normalizedInput.match(/gitlab\.com\/([^/]+)\/([^/]+)/);
   if (gitlabRepoMatch) {
     const [, owner, repo] = gitlabRepoMatch;
     const cleanRepo = repo?.replace(/\.git$/, "");
@@ -1832,8 +1838,8 @@ function parseSource(input) {
       url: `https://gitlab.com/${owner}/${cleanRepo}.git`
     };
   }
-  const shorthandMatch = input.match(/^([^/]+)\/([^/]+)(?:\/(.+))?$/);
-  if (shorthandMatch && !input.includes(":") && !input.startsWith(".") && !input.startsWith("/")) {
+  const shorthandMatch = normalizedInput.match(/^([^/]+)\/([^/]+)(?:\/(.+))?$/);
+  if (shorthandMatch && !normalizedInput.includes(":") && !normalizedInput.startsWith(".") && !normalizedInput.startsWith("/")) {
     const [, owner, repo, subpath] = shorthandMatch;
     return {
       type: "github",
@@ -1841,11 +1847,53 @@ function parseSource(input) {
       subpath
     };
   }
+  if (isWellKnownUrl(normalizedInput)) {
+    return {
+      type: "well-known",
+      url: normalizedInput
+    };
+  }
   return {
     type: "git",
-    url: input
+    url: normalizedInput
   };
 }
+function isWellKnownUrl(input) {
+  if (!input.startsWith("http://") && !input.startsWith("https://")) {
+    return false;
+  }
+  try {
+    const parsed = new URL(input);
+    const excludedHosts = [
+      "github.com",
+      "gitlab.com",
+      "huggingface.co",
+      "raw.githubusercontent.com"
+    ];
+    if (excludedHosts.includes(parsed.hostname)) {
+      return false;
+    }
+    if (input.toLowerCase().endsWith("/skill.md")) {
+      return false;
+    }
+    if (input.endsWith(".git")) {
+      return false;
+    }
+    return true;
+  } catch {
+    return false;
+  }
+}
+function shouldPrefixHttps(input) {
+  if (input.startsWith("http://") || input.startsWith("https://")) {
+    return false;
+  }
+  const firstSegment = input.split("/")[0] ?? "";
+  if (!firstSegment || firstSegment.includes("@")) {
+    return false;
+  }
+  return firstSegment.includes(".");
+}
 
 // src/flows/install-tracking.ts
 async function recordMarketplaceTracking(skills, results, installGlobally, originBySkillName) {
@@ -2363,9 +2411,9 @@ function AddScopeScreen() {
 
 // src/tui/screens/AddSkillSelect.tsx
 import { existsSync as existsSync5 } from "fs";
-import { mkdir as mkdir4, mkdtemp as mkdtemp3, writeFile as writeFile3 } from "fs/promises";
-import { tmpdir as tmpdir4 } from "os";
-import { basename as basename3, join as join12 } from "path";
+import { mkdir as mkdir5, mkdtemp as mkdtemp4, writeFile as writeFile4 } from "fs/promises";
+import { tmpdir as tmpdir5 } from "os";
+import { join as join13 } from "path";
 import { Box as Box15, Text as Text13 } from "ink";
 import React11 from "react";
 
@@ -2620,9 +2668,231 @@ var RawSkillProvider = class {
 };
 var rawSkillProvider = new RawSkillProvider();
 
+// src/providers/wellknown.ts
+import matter6 from "gray-matter";
+var WellKnownProvider = class {
+  id = "well-known";
+  displayName = "Well-Known Skills";
+  WELL_KNOWN_PATH = ".well-known/skills";
+  INDEX_FILE = "index.json";
+  match(url) {
+    if (!url.startsWith("http://") && !url.startsWith("https://")) {
+      return { matches: false };
+    }
+    if (!url.includes(`/${this.WELL_KNOWN_PATH}/`)) {
+      return { matches: false };
+    }
+    return { matches: true, sourceIdentifier: this.getSourceIdentifier(url) };
+  }
+  async fetchIndex(baseUrl) {
+    try {
+      const parsed = new URL(baseUrl);
+      const basePath = parsed.pathname.replace(/\/$/, "");
+      const urlsToTry = [
+        {
+          indexUrl: `${parsed.protocol}//${parsed.host}${basePath}/${this.WELL_KNOWN_PATH}/${this.INDEX_FILE}`,
+          baseUrl: `${parsed.protocol}//${parsed.host}${basePath}`
+        }
+      ];
+      if (basePath && basePath !== "") {
+        urlsToTry.push({
+          indexUrl: `${parsed.protocol}//${parsed.host}/${this.WELL_KNOWN_PATH}/${this.INDEX_FILE}`,
+          baseUrl: `${parsed.protocol}//${parsed.host}`
+        });
+      }
+      for (const { indexUrl, baseUrl: resolvedBase } of urlsToTry) {
+        try {
+          const response = await fetch(indexUrl);
+          if (!response.ok) {
+            continue;
+          }
+          const index = await response.json();
+          if (!index.skills || !Array.isArray(index.skills)) {
+            continue;
+          }
+          let allValid = true;
+          for (const entry of index.skills) {
+            if (!this.isValidSkillEntry(entry)) {
+              allValid = false;
+              break;
+            }
+          }
+          if (allValid) {
+            return { index, resolvedBaseUrl: resolvedBase };
+          }
+        } catch {
+        }
+      }
+      return null;
+    } catch {
+      return null;
+    }
+  }
+  isValidSkillEntry(entry) {
+    if (!entry || typeof entry !== "object") return false;
+    const e = entry;
+    if (typeof e.name !== "string" || !e.name) return false;
+    if (typeof e.description !== "string" || !e.description) return false;
+    if (!Array.isArray(e.files) || e.files.length === 0) return false;
+    const nameRegex = /^[a-z0-9]([a-z0-9-]{0,62}[a-z0-9])?$/;
+    if (!nameRegex.test(e.name) && e.name.length > 1) {
+      if (e.name.length === 1 && !/^[a-z0-9]$/.test(e.name)) {
+        return false;
+      }
+    }
+    for (const file of e.files) {
+      if (typeof file !== "string") return false;
+      if (file.startsWith("/") || file.startsWith("\\") || file.includes("..")) return false;
+    }
+    const hasSkillMd2 = e.files.some((f) => typeof f === "string" && f.toLowerCase() === "skill.md");
+    if (!hasSkillMd2) return false;
+    return true;
+  }
+  async fetchSkill(url) {
+    try {
+      const parsed = new URL(url);
+      const skillMatch = parsed.pathname.match(/^(.*)\/\.well-known\/skills\/([^/]+)\/SKILL\.md$/i);
+      if (skillMatch) {
+        const baseUrl = `${parsed.protocol}//${parsed.host}${skillMatch[1] || ""}`;
+        const skillName2 = skillMatch[2];
+        const result2 = await this.fetchIndex(baseUrl);
+        if (result2) {
+          const entry = result2.index.skills.find((s) => s.name === skillName2);
+          if (entry) {
+            const fetched = await this.fetchSkillByEntry(result2.resolvedBaseUrl, entry);
+            if (fetched) {
+              return fetched;
+            }
+          }
+        }
+      }
+      const result = await this.fetchIndex(url);
+      if (!result) {
+        return null;
+      }
+      const { index, resolvedBaseUrl } = result;
+      let skillName = null;
+      const pathMatch = parsed.pathname.match(/\/.well-known\/skills\/([^/]+)\/?$/);
+      if (pathMatch?.[1] && pathMatch[1] !== "index.json") {
+        skillName = pathMatch[1];
+      } else if (index.skills.length === 1) {
+        skillName = index.skills[0]?.name ?? null;
+      }
+      if (!skillName) {
+        return null;
+      }
+      const skillEntry = index.skills.find((s) => s.name === skillName);
+      if (!skillEntry) {
+        return null;
+      }
+      return await this.fetchSkillByEntry(resolvedBaseUrl, skillEntry);
+    } catch {
+      return null;
+    }
+  }
+  async fetchSkillByEntry(baseUrl, entry) {
+    try {
+      const skillBaseUrl = `${baseUrl.replace(/\/$/, "")}/${this.WELL_KNOWN_PATH}/${entry.name}`;
+      const skillMdUrl = `${skillBaseUrl}/SKILL.md`;
+      const response = await fetch(skillMdUrl);
+      if (!response.ok) {
+        return null;
+      }
+      const content = await response.text();
+      const { data } = matter6(content);
+      if (!data.name || !data.description) {
+        return null;
+      }
+      const files = /* @__PURE__ */ new Map();
+      files.set("SKILL.md", content);
+      const otherFiles = entry.files.filter((f) => f.toLowerCase() !== "skill.md");
+      const filePromises = otherFiles.map(async (filePath) => {
+        try {
+          const fileUrl = `${skillBaseUrl}/${filePath}`;
+          const fileResponse = await fetch(fileUrl);
+          if (fileResponse.ok) {
+            const fileContent = await fileResponse.text();
+            return { path: filePath, content: fileContent };
+          }
+        } catch {
+          return null;
+        }
+        return null;
+      });
+      const fileResults = await Promise.all(filePromises);
+      for (const result of fileResults) {
+        if (result) {
+          files.set(result.path, result.content);
+        }
+      }
+      return {
+        name: data.name,
+        description: data.description,
+        content,
+        installName: entry.name,
+        sourceUrl: skillMdUrl,
+        metadata: data.metadata,
+        files,
+        indexEntry: entry
+      };
+    } catch {
+      return null;
+    }
+  }
+  async fetchAllSkills(url) {
+    try {
+      const result = await this.fetchIndex(url);
+      if (!result) {
+        return [];
+      }
+      const { index, resolvedBaseUrl } = result;
+      const skillPromises = index.skills.map(
+        (entry) => this.fetchSkillByEntry(resolvedBaseUrl, entry)
+      );
+      const results = await Promise.all(skillPromises);
+      return results.filter((skill) => Boolean(skill));
+    } catch {
+      return [];
+    }
+  }
+  toRawUrl(url) {
+    try {
+      const parsed = new URL(url);
+      if (url.toLowerCase().endsWith("/skill.md")) {
+        return url;
+      }
+      const pathMatch = parsed.pathname.match(/\/.well-known\/skills\/([^/]+)\/?$/);
+      if (pathMatch?.[1]) {
+        const basePath2 = parsed.pathname.replace(/\/.well-known\/skills\/.*$/, "");
+        return `${parsed.protocol}//${parsed.host}${basePath2}/${this.WELL_KNOWN_PATH}/${pathMatch[1]}/SKILL.md`;
+      }
+      const basePath = parsed.pathname.replace(/\/$/, "");
+      return `${parsed.protocol}//${parsed.host}${basePath}/${this.WELL_KNOWN_PATH}/${this.INDEX_FILE}`;
+    } catch {
+      return url;
+    }
+  }
+  getSourceIdentifier(url) {
+    try {
+      const parsed = new URL(url);
+      const hostParts = parsed.hostname.split(".");
+      if (hostParts.length >= 2) {
+        const tld = hostParts[hostParts.length - 1];
+        const sld = hostParts[hostParts.length - 2];
+        return `${sld}/${tld}`;
+      }
+      return parsed.hostname.replace(".", "/");
+    } catch {
+      return "unknown/unknown";
+    }
+  }
+};
+var wellKnownProvider = new WellKnownProvider();
+
 // src/providers/index.ts
 registerProvider(mintlifyProvider);
 registerProvider(huggingFaceProvider);
+registerProvider(wellKnownProvider);
 registerProvider(rawSkillProvider);
 
 // src/flows/remote-skill.ts
@@ -2678,10 +2948,56 @@ async function resolveRemoteSkill(url) {
   };
 }
 
+// src/flows/well-known-skills.ts
+import { mkdir as mkdir4, mkdtemp as mkdtemp3, writeFile as writeFile3 } from "fs/promises";
+import { tmpdir as tmpdir4 } from "os";
+import { dirname as dirname3, join as join11 } from "path";
+async function prepareWellKnownSkills(sourceUrl) {
+  const discovered = await wellKnownProvider.fetchAllSkills(sourceUrl);
+  if (discovered.length === 0) {
+    throw new Error(
+      "No skills found at this URL. Make sure it exposes /.well-known/skills/index.json."
+    );
+  }
+  const tempDir = await mkdtemp3(join11(tmpdir4(), "playbooks-skill-"));
+  registerTempDir(tempDir);
+  await mkdir4(tempDir, { recursive: true });
+  const originMap = /* @__PURE__ */ new Map();
+  const skills = [];
+  const sourceIdentifier = wellKnownProvider.getSourceIdentifier(sourceUrl);
+  for (const skill of discovered) {
+    const skillDir = join11(tempDir, skill.installName);
+    await mkdir4(skillDir, { recursive: true });
+    for (const [filePath, content] of skill.files.entries()) {
+      const targetPath = join11(skillDir, filePath);
+      if (!isPathSafe(skillDir, targetPath)) {
+        throw new Error("Invalid file path in well-known skill index.");
+      }
+      await mkdir4(dirname3(targetPath), { recursive: true });
+      await writeFile3(targetPath, content, "utf-8");
+    }
+    const localSkill = {
+      name: skill.installName,
+      description: skill.description,
+      path: skillDir,
+      rawContent: skill.content,
+      metadata: skill.metadata
+    };
+    skills.push(localSkill);
+    originMap.set(getSkillDisplayName(localSkill), {
+      sourceType: "well-known",
+      sourceUrl: skill.sourceUrl,
+      source: sourceIdentifier,
+      skillPath: skill.sourceUrl
+    });
+  }
+  return { tempDir, skills, originBySkillName: originMap };
+}
+
 // src/marketplace.ts
 import { existsSync as existsSync4, statSync } from "fs";
 import { readFile as readFile3 } from "fs/promises";
-import { dirname as dirname3, join as join11, posix } from "path";
+import { dirname as dirname4, join as join12, posix } from "path";
 function toRecord(value) {
   if (!value || typeof value !== "object" || Array.isArray(value)) return null;
   return value;
@@ -2752,7 +3068,7 @@ function resolveLocalMarketplacePath(input) {
     return input;
   }
   if (stats.isDirectory()) {
-    const candidate = join11(input, ".claude-plugin", "marketplace.json");
+    const candidate = join12(input, ".claude-plugin", "marketplace.json");
     if (existsSync4(candidate)) return candidate;
   }
   return null;
@@ -2769,7 +3085,7 @@ async function loadMarketplace(input, ref) {
     }
     const content = await readFile3(localPath, "utf-8");
     const json = JSON.parse(content);
-    return { json, context: { kind: "local", baseDir: dirname3(localPath) } };
+    return { json, context: { kind: "local", baseDir: dirname4(localPath) } };
   }
   if (isOwnerRepoShorthand(input)) {
     const [owner, repo] = input.split("/");
@@ -2881,8 +3197,8 @@ function resolvePluginSource(plugin, context) {
   const src = plugin.source;
   if (typeof src === "string") {
     if (context.kind === "local" && context.baseDir) {
-      const base = join11(context.baseDir, pluginRoot);
-      return { kind: "local", localDir: join11(base, src), overrides };
+      const base = join12(context.baseDir, pluginRoot);
+      return { kind: "local", localDir: join12(base, src), overrides };
     }
     if (context.kind === "github" && context.gh) {
       const basePath = posix.join(context.gh.basePath || "", pluginRoot || "");
@@ -3056,6 +3372,34 @@ function MultiSelect({
   ] });
 }
 
+// src/tui/utils/skill-selection.ts
+import { basename as basename3 } from "path";
+function matchesSkillName(skill, input) {
+  const normalized = input.toLowerCase();
+  const byName = skill.name.toLowerCase() === normalized;
+  const byPath = basename3(skill.path).toLowerCase() === normalized;
+  return byName || byPath;
+}
+function autoSelect(skills, options) {
+  if (options.skill && options.skill.length > 0) {
+    const selected = skills.filter((s) => options.skill?.some((name) => matchesSkillName(s, name)));
+    if (selected.length === 0) {
+      return {
+        status: "prompt",
+        message: `No matching skills found for: ${options.skill.join(", ")}`
+      };
+    }
+    return { status: "selected", skills: selected };
+  }
+  if (skills.length === 1) {
+    return { status: "selected", skills };
+  }
+  if (options.yes) {
+    return { status: "selected", skills };
+  }
+  return { status: "prompt" };
+}
+
 // src/tui/screens/AddSkillSelect.tsx
 import { jsx as jsx17, jsxs as jsxs13 } from "react/jsx-runtime";
 function AddSkillSelectScreen() {
@@ -3113,11 +3457,11 @@ function AddSkillSelectScreen() {
           if (!resolved) {
             throw new Error("Unable to fetch SKILL.md from that URL.");
           }
-          const tempDir2 = await mkdtemp3(join12(tmpdir4(), "playbooks-skill-"));
+          const tempDir2 = await mkdtemp4(join13(tmpdir5(), "playbooks-skill-"));
           registerTempDir(tempDir2);
           tempDirForCleanup = tempDir2;
-          await mkdir4(tempDir2, { recursive: true });
-          await writeFile3(join12(tempDir2, "SKILL.md"), resolved.remoteSkill.content, "utf-8");
+          await mkdir5(tempDir2, { recursive: true });
+          await writeFile4(join13(tempDir2, "SKILL.md"), resolved.remoteSkill.content, "utf-8");
           const skill = {
             name: resolved.remoteSkill.installName,
             description: resolved.remoteSkill.description,
@@ -3143,6 +3487,38 @@ function AddSkillSelectScreen() {
           navigateTo("add-targets");
           return;
         }
+        if (parsed.type === "well-known") {
+          const prepared = await prepareWellKnownSkills(parsed.url);
+          tempDirForCleanup = prepared.tempDir;
+          updateAddSkill({
+            parsed,
+            tempDir: prepared.tempDir,
+            skills: prepared.skills,
+            originBySkillName: prepared.originBySkillName
+          });
+          if (options.list) {
+            keepTempDir = true;
+            setListMode(true);
+            setStatus("list");
+            return;
+          }
+          const autoSelection2 = autoSelect(prepared.skills, options);
+          if (autoSelection2.status === "selected") {
+            keepTempDir = true;
+            updateAddSkill({ selectedSkills: autoSelection2.skills });
+            navigateTo("add-targets");
+            return;
+          }
+          if (autoSelection2.status === "error") {
+            throw new Error(autoSelection2.message);
+          }
+          if (autoSelection2.status === "prompt" && autoSelection2.message) {
+            setFlash(autoSelection2.message);
+          }
+          keepTempDir = true;
+          setStatus("ready");
+          return;
+        }
         let skillsDir = "";
         let tempDir = null;
         if (parsed.type === "local") {
@@ -3317,31 +3693,6 @@ function AddSkillSelectScreen() {
     )
   ] });
 }
-function matchesSkillName(skill, input) {
-  const normalized = input.toLowerCase();
-  const byName = skill.name.toLowerCase() === normalized;
-  const byPath = basename3(skill.path).toLowerCase() === normalized;
-  return byName || byPath;
-}
-function autoSelect(skills, options) {
-  if (options.skill && options.skill.length > 0) {
-    const selected = skills.filter((s) => options.skill?.some((name) => matchesSkillName(s, name)));
-    if (selected.length === 0) {
-      return {
-        status: "prompt",
-        message: `No matching skills found for: ${options.skill.join(", ")}`
-      };
-    }
-    return { status: "selected", skills: selected };
-  }
-  if (skills.length === 1) {
-    return { status: "selected", skills };
-  }
-  if (options.yes) {
-    return { status: "selected", skills };
-  }
-  return { status: "prompt" };
-}
 
 // src/tui/screens/AddSource.tsx
 import { Box as Box16, Text as Text14 } from "ink";
@@ -3431,10 +3782,11 @@ function AddSourceScreen() {
 // src/tui/screens/AddTargets.tsx
 import { Box as Box17, Text as Text15 } from "ink";
 import React14 from "react";
-import { jsx as jsx19, jsxs as jsxs15 } from "react/jsx-runtime";
+import { Fragment, jsx as jsx19, jsxs as jsxs15 } from "react/jsx-runtime";
 function AddTargetsScreen() {
   const { invocation, addSkill, updateAddSkill, navigateTo, setFlash, navAction } = useNavigation();
   const [status, setStatus] = React14.useState("loading");
+  const [mode, setMode] = React14.useState("choice");
   const [availableAgents, setAvailableAgents] = React14.useState([]);
   const [showLoading, setShowLoading] = React14.useState(false);
   const spinner = useSpinnerFrame(status === "loading");
@@ -3447,6 +3799,7 @@ function AddTargetsScreen() {
       const list = installed.length > 0 ? installed : Object.keys(agents);
       setAvailableAgents(list);
       setStatus("ready");
+      setMode("choice");
       if (navAction !== "pop" && addSkill.targetAgents && addSkill.targetAgents.length > 0) {
         navigateTo("add-scope");
         return;
@@ -3505,7 +3858,40 @@ function AddTargetsScreen() {
     value: agent,
     label: agents[agent].displayName
   }));
-  return /* @__PURE__ */ jsxs15(Box17, { flexDirection: "column", padding: 1, children: [
+  return /* @__PURE__ */ jsx19(Box17, { flexDirection: "column", padding: 1, children: mode === "choice" ? /* @__PURE__ */ jsxs15(Fragment, { children: [
+    /* @__PURE__ */ jsx19(AddFlowHeader, { title: "Install to" }),
+    /* @__PURE__ */ jsx19(
+      SingleSelect,
+      {
+        items: [
+          {
+            label: "All detected agents (Recommended)",
+            value: "all",
+            hint: `Install to all ${availableAgents.length} detected agents`
+          },
+          {
+            label: "Select specific agents",
+            value: "select",
+            hint: "Choose a subset of detected agents"
+          }
+        ],
+        initialValue: "all",
+        onSubmit: (value) => {
+          if (value === "all") {
+            updateAddSkill({
+              targetAgents: availableAgents,
+              installGlobally: void 0,
+              installMode: void 0,
+              planLines: void 0
+            });
+            navigateTo("add-scope");
+            return;
+          }
+          setMode("select");
+        }
+      }
+    )
+  ] }) : /* @__PURE__ */ jsxs15(Fragment, { children: [
     /* @__PURE__ */ jsx19(AddFlowHeader, { title: "Select agents" }),
     /* @__PURE__ */ jsx19(
       MultiSelect,
@@ -3527,7 +3913,7 @@ function AddTargetsScreen() {
         }
       }
     )
-  ] });
+  ] }) });
 }
 
 // src/tui/screens/FindSkillResults.tsx
@@ -3796,16 +4182,16 @@ import React18 from "react";
 
 // src/installed-skills.ts
 import { lstat as lstat2, readFile as readFile4, readdir as readdir3, stat as stat2 } from "fs/promises";
-import { basename as basename4, join as join13 } from "path";
-import matter6 from "gray-matter";
+import { basename as basename4, join as join14 } from "path";
+import matter7 from "gray-matter";
 function getAgentSkillsDir(agent, scope, cwd) {
   const config = agents[agent];
-  return scope === "global" ? config.globalSkillsDir : join13(cwd, config.skillsDir);
+  return scope === "global" ? config.globalSkillsDir : join14(cwd, config.skillsDir);
 }
 async function readSkillFrontmatter(skillMdPath) {
   try {
     const content = await readFile4(skillMdPath, "utf-8");
-    const { data } = matter6(content);
+    const { data } = matter7(content);
     return {
       name: typeof data.name === "string" ? data.name : void 0,
       description: typeof data.description === "string" ? data.description : void 0
@@ -3824,7 +4210,7 @@ async function listSkillsForAgent(agent, scope, cwd = process.cwd()) {
         continue;
       }
       const slug = entry.name;
-      const skillDir = join13(dir, slug);
+      const skillDir = join14(dir, slug);
       const isSymlink = entry.isSymbolicLink();
       let isBroken = false;
       if (isSymlink) {
@@ -3834,7 +4220,7 @@ async function listSkillsForAgent(agent, scope, cwd = process.cwd()) {
           isBroken = true;
         }
       }
-      const skillMdPath = join13(skillDir, "SKILL.md");
+      const skillMdPath = join14(skillDir, "SKILL.md");
       if (isBroken) {
         skills.push({
           slug,
@@ -3877,7 +4263,7 @@ async function findSkillInstallations(skillName, scope, cwd = process.cwd()) {
   }
   for (const agent of Object.keys(agents)) {
     const baseDir = getAgentSkillsDir(agent, scope, cwd);
-    const skillDir = join13(baseDir, sanitized);
+    const skillDir = join14(baseDir, sanitized);
     try {
       const stats = await lstat2(skillDir);
       installs.push({
@@ -4291,14 +4677,14 @@ import { Box as Box25, Text as Text22 } from "ink";
 import React21 from "react";
 
 // src/flows/marketplace.ts
-import { dirname as dirname4, join as join14, relative as relative2 } from "path";
+import { dirname as dirname5, join as join15, relative as relative2 } from "path";
 function normalizeCandidatePath(basePath, candidate) {
   if (!candidate) return basePath;
   const cleaned = candidate.replace(/\\/g, "/");
   if (cleaned.endsWith(".md")) {
-    return join14(basePath, dirname4(cleaned));
+    return join15(basePath, dirname5(cleaned));
   }
-  return join14(basePath, cleaned);
+  return join15(basePath, cleaned);
 }
 function collectOverridePaths(overrides) {
   const paths = ["skills", "commands", "agents", "hooks"];
@@ -4375,7 +4761,7 @@ async function collectMarketplaceSkills(plugins, context) {
       const key = `github:${owner}/${repo}@${ref}`;
       const repoUrl = `https://github.com/${owner}/${repo}.git`;
       const { tempDir } = await ensureRepoClone(key, repoUrl, ref);
-      const repoRoot = join14(tempDir, path || "");
+      const repoRoot = join15(tempDir, path || "");
       const baseDir = normalizeCandidatePath(repoRoot, plugin.pluginRoot || "");
       const overridePaths = collectOverridePaths(resolved.overrides);
       const scanned = /* @__PURE__ */ new Set();
@@ -4407,7 +4793,7 @@ async function collectMarketplaceSkills(plugins, context) {
       const key = `gitlab:${namespacePath}/${repo}@${ref}`;
       const repoUrl = `https://gitlab.com/${namespacePath}/${repo}.git`;
       const { tempDir } = await ensureRepoClone(key, repoUrl, ref);
-      const repoRoot = join14(tempDir, path || "");
+      const repoRoot = join15(tempDir, path || "");
       const baseDir = normalizeCandidatePath(repoRoot, plugin.pluginRoot || "");
       const overridePaths = collectOverridePaths(resolved.overrides);
       const scanned = /* @__PURE__ */ new Set();
@@ -4594,9 +4980,9 @@ import { Box as Box26, Text as Text23, useInput as useInput5 } from "ink";
 import React22 from "react";
 
 // src/flows/update-skills.ts
-import { mkdir as mkdir5, mkdtemp as mkdtemp4, rm as rm6, stat as stat3, writeFile as writeFile4 } from "fs/promises";
-import { tmpdir as tmpdir5 } from "os";
-import { dirname as dirname5, join as join15 } from "path";
+import { mkdir as mkdir6, mkdtemp as mkdtemp5, rm as rm6, stat as stat3, writeFile as writeFile5 } from "fs/promises";
+import { tmpdir as tmpdir6 } from "os";
+import { dirname as dirname6, join as join16 } from "path";
 var repoTreeCache = /* @__PURE__ */ new Map();
 function normalizeSkillFolderPath(skillPath) {
   let folderPath = skillPath;
@@ -4691,8 +5077,8 @@ async function updateFromRepo(target) {
     let sourceDir = null;
     if (target.entry.skillPath) {
       const normalizedPath = target.entry.skillPath.replace(/\\/g, "/");
-      const skillDir = join15(tempDir, dirname5(normalizedPath));
-      if (await pathExists(join15(skillDir, "SKILL.md"))) {
+      const skillDir = join16(tempDir, dirname6(normalizedPath));
+      if (await pathExists(join16(skillDir, "SKILL.md"))) {
         sourceDir = skillDir;
       }
     }
@@ -4714,10 +5100,15 @@ async function updateFromRepo(target) {
 async function updateFromRemote(target) {
   const provider = findProvider(target.entry.sourceUrl);
   let content = null;
+  let files = null;
   if (provider) {
     const skill = await provider.fetchSkill(target.entry.sourceUrl);
     if (skill) {
-      content = skill.content;
+      if ("files" in skill && skill.files instanceof Map) {
+        files = skill.files;
+      } else {
+        content = skill.content;
+      }
     }
   } else if (target.entry.sourceType === "mintlify") {
     const legacy = await fetchMintlifySkill(target.entry.sourceUrl);
@@ -4725,14 +5116,25 @@ async function updateFromRemote(target) {
       content = legacy.content;
     }
   }
-  if (!content) {
+  if (!content && !files) {
     return false;
   }
-  const tempDir = await mkdtemp4(join15(tmpdir5(), "playbooks-skill-"));
+  const tempDir = await mkdtemp5(join16(tmpdir6(), "playbooks-skill-"));
   registerTempDir(tempDir);
   try {
-    await mkdir5(tempDir, { recursive: true });
-    await writeFile4(join15(tempDir, "SKILL.md"), content, "utf-8");
+    await mkdir6(tempDir, { recursive: true });
+    if (files) {
+      for (const [filePath, fileContent] of files.entries()) {
+        const targetPath = join16(tempDir, filePath);
+        if (!isPathSafe(tempDir, targetPath)) {
+          continue;
+        }
+        await mkdir6(dirname6(targetPath), { recursive: true });
+        await writeFile5(targetPath, fileContent, "utf-8");
+      }
+    } else if (content) {
+      await writeFile5(join16(tempDir, "SKILL.md"), content, "utf-8");
+    }
     return await applyUpdateFromDir(target.name, target.scope, tempDir);
   } finally {
     await cleanupTempDir(tempDir);
@@ -5003,7 +5405,7 @@ function sortTargets(a, b) {
 }
 
 // src/tui/ScreenRouter.tsx
-import { Fragment, jsx as jsx29, jsxs as jsxs24 } from "react/jsx-runtime";
+import { Fragment as Fragment2, jsx as jsx29, jsxs as jsxs24 } from "react/jsx-runtime";
 function ScreenRouter() {
   const { screen } = useNavigation();
   const render2 = (s) => {
@@ -5046,7 +5448,7 @@ function ScreenRouter() {
         return null;
     }
   };
-  return /* @__PURE__ */ jsxs24(Fragment, { children: [
+  return /* @__PURE__ */ jsxs24(Fragment2, { children: [
     /* @__PURE__ */ jsx29(BrandHeader, {}),
     render2(screen),
     /* @__PURE__ */ jsx29(FlashBar, { align: "center" })
@@ -5145,7 +5547,7 @@ function runApp(initialInvocation, initialScreen) {
 var version = package_default.version;
 setVersion(version);
 setupTempDirCleanup();
-program.name("playbooks").description("Playbooks CLI").version(version);
+program.name("playbooks").description("playbooks CLI").version(version);
 program.addHelpCommand();
 var applyAddSkillOptions = (cmd) => cmd.option("-g, --global", "Install globally (user-level) instead of project-level").option(
   "-a, --agent <agents...>",
@@ -5283,6 +5685,36 @@ program.command("get <url> [outKeyword] [outPath]").description("Fetch a URL as
       }
       outputPath = outPath;
     }
+    const shouldUseTui = Boolean(process.stdout.isTTY) && !outputPath;
+    if (!shouldUseTui) {
+      try {
+        const data = await fetchUrlMarkdown(url);
+        if (outputPath) {
+          if (options.json) {
+            writeFileSync(outputPath, `${JSON.stringify(data, null, 2)}
+`, "utf8");
+            return;
+          }
+          const body3 = data.markdown.endsWith("\n") ? data.markdown : `${data.markdown}
+`;
+          writeFileSync(outputPath, body3, "utf8");
+          return;
+        }
+        if (options.json) {
+          process.stdout.write(`${JSON.stringify(data, null, 2)}
+`);
+          return;
+        }
+        const body2 = data.markdown.endsWith("\n") ? data.markdown : `${data.markdown}
+`;
+        process.stdout.write(body2);
+        return;
+      } catch (error) {
+        const message = error instanceof Error ? error.message : "Failed to fetch markdown.";
+        console.error(`Failed to fetch markdown: ${message}`);
+        process.exit(1);
+      }
+    }
     await runApp(
       { intent: "get-url", source: url, options: { json: options.json, output: outputPath } },
       "get-url"

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "playbooks",
-  "version": "0.1.7",
+  "version": "0.1.9",
   "description": "Install agent skills, MCPs and docs into your coding agents from any git repository.",
   "type": "module",
   "bin": {