@impulselab/directory 1.0.6 → 1.0.8

package/index.js

@@ -48,6 +48,7 @@ const MODES = {
 const INSTALLATION_TARGETS = {
   CLAUDE_SLASH: 'claude-slash',
   CLAUDE_SUB_AGENT: 'claude-sub-agent',
+  CLAUDE_SKILL: 'claude-skill',
   CURSOR_COMMAND: 'cursor-command',
   CURSOR_RULE: 'cursor-rule',
 };
@@ -67,6 +68,13 @@ const TARGET_CONFIG = {
     resolveDirectory: () => resolveClaudeDirectory('agents'),
     extension: '.md',
   },
+  [INSTALLATION_TARGETS.CLAUDE_SKILL]: {
+    label: 'Claude Code skill',
+    description: '.claude/skills (project only)',
+    resolveDirectory: () => resolveClaudeSkillsDirectory(),
+    extension: '.md',
+    isSkill: true,
+  },
   [INSTALLATION_TARGETS.CURSOR_COMMAND]: {
     label: 'Cursor command',
     description: '.cursor/commands (project only)',
@@ -133,76 +141,41 @@ function shouldUseHttps(baseUrl) {
   return true;
 }
 
-function downloadCommand(baseUrl, fullPath) {
-  return new Promise((resolve, reject) => {
-    const useHttps = shouldUseHttps(baseUrl);
-    const protocol = useHttps ? https : http;
-    const scheme = useHttps ? 'https' : 'http';
-
-    const url = `${scheme}://${baseUrl}${RAW_PATH}${fullPath}`;
-
-    protocol
-      .get(url, (res) => {
-        if (res.statusCode === 200) {
-          let data = '';
-          res.on('data', (chunk) => {
-            data += chunk;
-          });
-          res.on('end', () => resolve(data));
-        } else if (res.statusCode === 404) {
-          reject(new Error(`Command '${fullPath}' not found (404)`));
-        } else if (useHttps && (res.statusCode === 500 || res.statusCode >= 400)) {
-          if (canFallbackToHttp(baseUrl)) {
-            console.log(`HTTPS failed (${res.statusCode}), trying HTTP...`);
-            downloadWithHttp(baseUrl, fullPath)
-              .then(resolve)
-              .catch(reject);
-          } else {
-            reject(new Error(`HTTPS failed (${res.statusCode}) and HTTP fallback is disabled`));
-          }
-        } else {
-          reject(new Error(`HTTP ${res.statusCode}: ${res.statusMessage}`));
-        }
-      })
-      .on('error', (err) => {
-        if (useHttps) {
-          if (canFallbackToHttp(baseUrl)) {
-            console.log(`HTTPS failed (${err.message}), trying HTTP...`);
-            downloadWithHttp(baseUrl, fullPath)
-              .then(resolve)
-              .catch(reject);
-          } else {
-            reject(err);
-          }
-        } else {
-          reject(err);
-        }
-      });
-  });
+function toKebabCase(input) {
+  return String(input)
+    .normalize('NFKD')                    // strip accents
+    .replace(/[\u0300-\u036f]/g, '')
+    .replace(/['"]/g, '')
+    .replace(/[^a-zA-Z0-9]+/g, '-')       // collapse non-alnum to dashes
+    .replace(/^-+|-+$/g, '')
+    .toLowerCase();
 }
 
-function downloadWithHttp(baseUrl, fullPath) {
-  return new Promise((resolve, reject) => {
-    const url = `http://${baseUrl}${RAW_PATH}${fullPath}`;
-
-    console.log(`Trying HTTP: ${url}`);
+function stripTrailingIdSegment(slug) {
+  const normalized = toKebabCase(slug || '');
+  const segments = normalized.split('-');
+  if (segments.length <= 1) return normalized;
+  const last = segments[segments.length - 1];
+  if (/^[a-z0-9]{5,}$/i.test(last)) {
+    segments.pop();
+  }
+  return segments.join('-');
+}
 
-    http
-      .get(url, (res) => {
-        if (res.statusCode === 200) {
-          let data = '';
-          res.on('data', (chunk) => {
-            data += chunk;
-          });
-          res.on('end', () => resolve(data));
-        } else if (res.statusCode === 404) {
-          reject(new Error(`Command '${fullPath}' not found (404)`));
-        } else {
-          reject(new Error(`HTTP ${res.statusCode}: ${res.statusMessage}`));
-        }
-      })
-      .on('error', reject);
-  });
+function sanitizeIdentifierForFilename(identifier) {
+  return String(identifier || '')
+    .normalize('NFKD')
+    .replace(/[\u0300-\u036f]/g, '')      // remove accents
+    .replace(/[\u0000-\u001f\u007f-\u009f]/g, '') // remove control chars
+    .replace(/[<>:"/\\|?*]/g, '')         // remove filesystem unsafe chars
+    .replace(/\.\./g, '')                 // remove parent directory traversal
+    .replace(/[/\\]+/g, '-')              // replace all path separators with dashes
+    .replace(/^\.+/g, '')                 // remove leading dots
+    .replace(/\.+$/g, '')                 // remove trailing dots
+    .replace(/^-+|-+$/g, '')              // trim edge dashes
+    .replace(/-+/g, '-')                  // collapse multiple dashes
+    .toLowerCase()
+    || 'unknown';                         // fallback for empty results
 }
 
 function downloadStack(baseUrl, stackId) {
@@ -290,6 +263,58 @@ function downloadStackWithHttp(baseUrl, stackId) {
   });
 }
 
+function downloadRawWithHeaders(baseUrl, fullPath) {
+  return new Promise((resolve, reject) => {
+    const useHttps = shouldUseHttps(baseUrl);
+    const protocol = useHttps ? https : http;
+    const scheme = useHttps ? 'https' : 'http';
+    const url = `${scheme}://${baseUrl}${RAW_PATH}${fullPath}`;
+
+    const handleOk = (res) => {
+      let data = '';
+      res.on('data', (chunk) => { data += chunk; });
+      res.on('end', () => resolve({ content: data, headers: res.headers }));
+    };
+
+    const handleHttpsFailover = (reason) => {
+      if (useHttps && canFallbackToHttp(baseUrl)) {
+        console.log(`HTTPS failed (${reason}), trying HTTP...`);
+        downloadRawWithHeadersHttp(baseUrl, fullPath).then(resolve).catch(reject);
+      } else {
+        reject(new Error(typeof reason === 'string' ? reason : reason.message));
+      }
+    };
+
+    protocol
+      .get(url, (res) => {
+        if (res.statusCode === 200) return handleOk(res);
+        if (res.statusCode === 404) return reject(new Error(`Command '${fullPath}' not found (404)`));
+        return handleHttpsFailover(`${res.statusCode}`);
+      })
+      .on('error', handleHttpsFailover);
+  });
+}
+
+function downloadRawWithHeadersHttp(baseUrl, fullPath) {
+  return new Promise((resolve, reject) => {
+    const url = `http://${baseUrl}${RAW_PATH}${fullPath}`;
+    console.log(`Trying HTTP: ${url}`);
+    http
+      .get(url, (res) => {
+        if (res.statusCode === 200) {
+          let data = '';
+          res.on('data', (chunk) => { data += chunk; });
+          res.on('end', () => resolve({ content: data, headers: res.headers }));
+        } else if (res.statusCode === 404) {
+          reject(new Error(`Command '${fullPath}' not found (404)`));
+        } else {
+          reject(new Error(`HTTP ${res.statusCode}: ${res.statusMessage}`));
+        }
+      })
+      .on('error', reject);
+  });
+}
+
 function findClosestFolder(folderName) {
   let currentDir = process.cwd();
 
@@ -327,6 +352,16 @@ function resolveCursorDirectory(subFolder) {
   return path.join(projectCursorDir, subFolder);
 }
 
+function resolveClaudeSkillsDirectory() {
+  const projectClaudeDir = findClosestFolder('.claude');
+  if (!projectClaudeDir) {
+    const message =
+      'Unable to find a .claude directory. Run this command from inside a project with a .claude folder.';
+    throw new Error(message);
+  }
+  return path.join(projectClaudeDir, 'skills');
+}
+
 function ensureDirectoryExists(dirPath) {
   if (!fs.existsSync(dirPath)) {
     fs.mkdirSync(dirPath, { recursive: true });
@@ -346,17 +381,36 @@ function saveCommand({
   fullPath,
   target,
 }) {
-  const filePath = path.join(directory, filename);
-  const relativeDir = path.relative(process.cwd(), directory);
-  const displayPath = relativeDir
-    ? path.join(relativeDir, filename)
-    : filename;
+  const targetConfig = TARGET_CONFIG[target];
+  const isSkill = targetConfig && targetConfig.isSkill;
+
+  let filePath;
+  let displayPath;
+  let commandName;
+
+  if (isSkill) {
+    const skillName = filename.replace(path.extname(filename), '');
+    const skillDir = path.join(directory, skillName);
+    ensureDirectoryExists(skillDir);
+    filePath = path.join(skillDir, 'SKILL.md');
+    const relativeDir = path.relative(process.cwd(), skillDir);
+    displayPath = relativeDir
+      ? path.join(relativeDir, 'SKILL.md')
+      : path.join(skillName, 'SKILL.md');
+    commandName = skillName;
+  } else {
+    filePath = path.join(directory, filename);
+    const relativeDir = path.relative(process.cwd(), directory);
+    displayPath = relativeDir
+      ? path.join(relativeDir, filename)
+      : filename;
+    commandName = filename.replace(path.extname(filename), '');
+  }
 
-  console.log(`📁 Saving command to ${displayPath}`);
+  console.log(`📁 Saving ${isSkill ? 'skill' : 'command'} to ${displayPath}`);
 
   fs.writeFileSync(filePath, content, 'utf8');
 
-  const commandName = filename.replace(path.extname(filename), '');
   logSuccessMessage(target, fullPath, commandName);
 }
 
@@ -372,6 +426,12 @@ function logSuccessMessage(target, fullPath, commandName) {
         `\n🎉 You can now select '${commandName}' from Claude Desktop's agent menu.`
       );
       break;
+    case INSTALLATION_TARGETS.CLAUDE_SKILL:
+      console.log(`✅ Skill '${fullPath}' installed successfully`);
+      console.log(
+        `\n🎉 Claude Code will now automatically use the '${commandName}' skill when relevant.`
+      );
+      break;
     case INSTALLATION_TARGETS.CURSOR_COMMAND:
       console.log(`✅ Cursor command '${fullPath}' installed successfully`);
       console.log(
@@ -505,13 +565,19 @@ async function main() {
 
       ensureDirectoryExists(directory);
 
-      const commandName = identifier.split('/').pop();
-      const simpleFilename = `${commandName}${targetConfig.extension}`;
-      const fallbackFilename = `${identifier.replace('/', '-')}${targetConfig.extension}`;
-      const fileExists = checkFileExists(directory, simpleFilename);
-      const filename = fileExists ? fallbackFilename : simpleFilename;
+      const commandNameFromPath = identifier.split('/').pop();
+      // First download the content to capture headers (and title)
+      const { content, headers } = await downloadRawWithHeaders(baseUrl, identifier);
+      const titleHeader = headers['x-prompt-title'];
+      const title = Array.isArray(titleHeader) ? titleHeader[0] : titleHeader;
+
+      const baseNameCandidate = title
+        ? toKebabCase(title)
+        : stripTrailingIdSegment(commandNameFromPath);
+      const finalBaseName = sanitizeIdentifierForFilename(baseNameCandidate);
 
-      const content = await downloadCommand(baseUrl, identifier);
+      // Overwrite if exists; do not append author or random suffix
+      const filename = `${finalBaseName}${targetConfig.extension}`;
 
       saveCommand({
         directory,
@@ -547,7 +613,9 @@ async function main() {
     for (let index = 0; index < prompts.length; index += 1) {
       const prompt = prompts[index];
       const commandPath = prompt.path || prompt.slug || prompt.id || `prompt-${index + 1}`;
-      const baseName = prompt.slug || `prompt-${index + 1}`;
+      const baseName = prompt.title
+        ? toKebabCase(prompt.title)
+        : stripTrailingIdSegment(prompt.slug || `prompt-${index + 1}`);
 
       const resolvedTarget = target || prompt.target || DEFAULT_TARGET;
       const targetConfig = TARGET_CONFIG[resolvedTarget];
@@ -560,30 +628,9 @@ async function main() {
       const directory = targetConfig.resolveDirectory();
       ensureDirectoryExists(directory);
 
-      const simpleFilename = `${baseName}${targetConfig.extension}`;
-      const fallbackBase = stack.slug
-        ? `${stack.slug}-${baseName}`
-        : `${stack.id || identifier}-${baseName}`;
-      const fallbackFilename = `${fallbackBase}${targetConfig.extension}`;
-
-      const simpleExists = checkFileExists(directory, simpleFilename);
-      const fallbackExists = checkFileExists(directory, fallbackFilename);
-
-      let filename = simpleFilename;
-      if (simpleExists) {
-        filename = fallbackFilename;
-      }
-      if ((simpleExists && fallbackExists) || checkFileExists(directory, filename)) {
-        const baseForUniq = fallbackBase;
-        const ext = targetConfig.extension;
-        let counter = 1;
-        let candidate = `${baseForUniq}-${counter}${ext}`;
-        while (checkFileExists(directory, candidate)) {
-          counter += 1;
-          candidate = `${baseForUniq}-${counter}${ext}`;
-        }
-        filename = candidate;
-      }
+      // Sanitize and overwrite if exists (no author or random suffix)
+      const sanitizedBaseName = sanitizeIdentifierForFilename(baseName);
+      const filename = `${sanitizedBaseName}${targetConfig.extension}`;
 
       if (!prompt.markdown) {
         console.warn(`⚠️  Skipping prompt '${commandPath}' (no content available)`);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@impulselab/directory",
-  "version": "1.0.6",
+  "version": "1.0.8",
   "description": "Download and install Claude commands from Impulse Directory",
   "main": "index.js",
   "bin": {