any-skills 0.1.1 → 0.1.3

package/README.md

@@ -1,22 +1,59 @@
 # any-skills
 
-When installed as a dependency, this package creates a shared skills directory (default: `.skills`) so Claude, Codex, and similar tools can reuse the same skills.
+Create a shared skills directory and link tool-specific folders so Claude, Codex,
+Gemini, and others can reuse the same skills.
 
-- `.claude/skills`
-- `.codex/skills`
+## What it does
 
-## How it works
+- Creates a shared `.skills` directory in the working directory (or uses the
+  configured target).
+- Creates tool links such as `.claude/skills` or `.codex/skills`.
+- Auto-detects `claude`, `codex`, and `gemini` commands on your PATH by default.
 
-The `postinstall` script runs at install time. It uses the user's install working directory as the root (prefers `INIT_CWD`, then `npm_config_local_prefix`, and falls back to `process.cwd()`). If the shared skills directory does not exist, it is created, then the tool-specific symlinks are generated (unless overridden by configuration).
+## Install
+
+```sh
+npm install any-skills --save-dev
+```
+
+Or install globally:
+
+```sh
+npm install -g any-skills
+```
+
+## Usage
+
+Create links in the current directory:
+
+```sh
+npx any-skills
+```
+
+Create links in your home directory (for example `~/.claude/skills`):
+
+```sh
+npx any-skills -g
+```
+
+Limit to specific tools:
+
+```sh
+npx any-skills claude
+npx any-skills deepseek
+```
+
+If a tool is not in the configured map, it links to `.<name>/skills` by default.
 
 ## Configuration
 
-You can customize which links are created by adding `.skillsrc` (JSON) in your project root.
+Create `.skillsrc` (JSON) in the working directory.
 
 Supported fields:
 
 - `target`: optional string. Overrides where skills are stored (default: `.skills`).
 - `links`: array of link definitions. Strings map to `target` by default.
+- `tools`: optional object mapping command names to link paths.
 
 Example:
 
@@ -27,22 +64,28 @@ Example:
 }
 ```
 
+Example (auto-detect commands):
+
+```json
+{
+  "tools": {
+    "claude": ".claude/skills",
+    "codex": ".codex/skills",
+    "gemini": ".gemini/skills"
+  }
+}
+```
+
 ## Cross-platform behavior
 
 - macOS / Linux uses `dir` symlinks
 - Windows uses `junction` for better compatibility
 
-## Usage
-
-```sh
-npm install any-skills --save-dev
-```
-
 ## Git ignore
 
 Add the tool-specific shared skill directories to your `.gitignore`:
 
 ```
-.claude.skills
-.codex.skills
+.claude/skills
+.codex/skills
 ```

package/package.json

@@ -1,9 +1,9 @@
 {
   "name": "any-skills",
-  "version": "0.1.1",
+  "version": "0.1.3",
   "description": "Share skills between Claude, Codex, and similar tools via a shared .skills directory.",
   "type": "commonjs",
-  "scripts": {
-    "postinstall": "node scripts/postinstall.js"
+  "bin": {
+    "any-skills": "scripts/cli.js"
   }
 }

package/scripts/cli.js

@@ -0,0 +1,30 @@
+#!/usr/bin/env node
+'use strict';
+
+const os = require('os');
+const { linkSkills } = require('./link-skills');
+
+function parseArgs(argv) {
+  const flags = new Set();
+  const tools = [];
+  for (const arg of argv) {
+    if (arg === '--global' || arg === '-g') {
+      flags.add('global');
+      continue;
+    }
+    if (arg.startsWith('-')) {
+      continue;
+    }
+    tools.push(arg);
+  }
+  return { flags, tools };
+}
+
+const rootDir = process.cwd();
+const { flags, tools } = parseArgs(process.argv.slice(2));
+const linkRoot = flags.has('global') ? os.homedir() : rootDir;
+const explicitTools = tools.length ? tools : null;
+const exitCode = linkSkills(rootDir, { linkRoot, explicitTools });
+if (exitCode) {
+  process.exit(exitCode);
+}

package/scripts/{postinstall.js → link-skills.js}

@@ -3,24 +3,13 @@
 const fs = require('fs');
 const path = require('path');
 
-function getInstallRoot() {
-  const initCwd = process.env.INIT_CWD;
-  if (initCwd) {
-    return path.resolve(initCwd);
-  }
-
-  const npmPrefix = process.env.npm_config_local_prefix;
-  if (npmPrefix) {
-    return path.resolve(npmPrefix);
-  }
-
-  return process.cwd();
-}
-
-const rootDir = getInstallRoot();
 const targetName = '.skills';
 const configFileName = '.skillsrc';
-const defaultLinkTargets = ['.claude/skills', '.codex/skills'];
+const defaultToolTargets = {
+  claude: '.claude/skills',
+  codex: '.codex/skills',
+  gemini: '.gemini/skills',
+};
 
 function ensureDir(dirPath) {
   if (!fs.existsSync(dirPath)) {
@@ -129,7 +118,7 @@ function resolveRootPath(value, baseDir) {
   return path.isAbsolute(value) ? value : path.join(baseDir, value);
 }
 
-function resolveTarget(config) {
+function resolveTarget(config, rootDir) {
   if (
     config &&
     typeof config.target === 'string' &&
@@ -141,7 +130,7 @@ function resolveTarget(config) {
   return path.join(rootDir, targetName);
 }
 
-function normalizeLinkEntry(entry, target, configPath) {
+function normalizeLinkEntry(entry, target, configPath, rootDir) {
   if (typeof entry === 'string') {
     return { link: entry, error: false };
   }
@@ -202,17 +191,108 @@ function getConfigEntries(config) {
   return null;
 }
 
-function buildLinkMappings({ config, configPath, exists, target }) {
+function commandExists(command) {
+  const pathEnv = process.env.PATH || '';
+  const pathEntries = pathEnv.split(path.delimiter).filter(Boolean);
+  const isWindows = process.platform === 'win32';
+  const extensions = isWindows
+    ? (process.env.PATHEXT || '.EXE;.CMD;.BAT;.COM')
+        .split(';')
+        .filter(Boolean)
+    : [''];
+
+  for (const entry of pathEntries) {
+    for (const ext of extensions) {
+      const candidate = path.join(entry, `${command}${ext}`);
+      try {
+        fs.accessSync(candidate, fs.constants.X_OK);
+        return true;
+      } catch (err) {
+        if (err.code !== 'ENOENT') {
+          continue;
+        }
+      }
+    }
+  }
+
+  return false;
+}
+
+function detectLinkTargets(config) {
+  const toolTargets =
+    config && config.tools && typeof config.tools === 'object'
+      ? config.tools
+      : defaultToolTargets;
+
+  const targets = [];
+  for (const [command, linkTarget] of Object.entries(toolTargets)) {
+    if (typeof linkTarget !== 'string' || linkTarget.trim() === '') {
+      continue;
+    }
+    if (commandExists(command)) {
+      targets.push(linkTarget);
+    }
+  }
+
+  return targets;
+}
+
+function resolveExplicitTargets(config, toolNames) {
+  const toolTargets =
+    config && config.tools && typeof config.tools === 'object'
+      ? config.tools
+      : defaultToolTargets;
+
+  const targets = [];
+  for (const name of toolNames) {
+    const mappedTarget = toolTargets[name];
+    if (typeof mappedTarget === 'string' && mappedTarget.trim() !== '') {
+      targets.push(mappedTarget);
+      continue;
+    }
+    const safeName = name.trim();
+    if (safeName) {
+      targets.push(`.${safeName}/skills`);
+    }
+  }
+
+  return targets;
+}
+
+function buildLinkMappings({
+  config,
+  configPath,
+  exists,
+  target,
+  rootDir,
+  linkRoot,
+  explicitTools,
+}) {
+  const resolvedLinkRoot = linkRoot || rootDir;
+  const explicitTargets = Array.isArray(explicitTools)
+    ? resolveExplicitTargets(config, explicitTools)
+    : null;
   const entries = getConfigEntries(config);
   if (!entries) {
+    if (explicitTargets) {
+      return {
+        mappings: explicitTargets.map((linkTarget) => ({
+          linkPath: resolveRootPath(linkTarget, resolvedLinkRoot),
+          targetPath: target,
+        })),
+        error: false,
+      };
+    }
+
     if (exists) {
       console.warn(
-        `[any-skills] No link configuration found in ${configPath}; using defaults.`
+        `[any-skills] No link configuration found in ${configPath}; using auto-detected tools.`
       );
     }
+    const detectedTargets = detectLinkTargets(config);
     return {
-      mappings: defaultLinkTargets.map((linkTarget) => ({
-        linkPath: resolveRootPath(linkTarget, rootDir),
+      mappings: detectedTargets.map((linkTarget) => ({
+        linkPath: resolveRootPath(linkTarget, resolvedLinkRoot),
         targetPath: target,
       })),
       error: false,
@@ -225,7 +305,7 @@ function buildLinkMappings({ config, configPath, exists, target }) {
 
   const mappings = [];
   for (const entry of entries) {
-    const normalized = normalizeLinkEntry(entry, target, configPath);
+    const normalized = normalizeLinkEntry(entry, target, configPath, rootDir);
     if (!normalized) {
       continue;
     }
@@ -233,7 +313,7 @@ function buildLinkMappings({ config, configPath, exists, target }) {
       return { mappings: [], error: true };
     }
     mappings.push({
-      linkPath: resolveRootPath(normalized.link, rootDir),
+      linkPath: resolveRootPath(normalized.link, resolvedLinkRoot),
       targetPath: target,
     });
   }
@@ -241,7 +321,7 @@ function buildLinkMappings({ config, configPath, exists, target }) {
   return { mappings, error: false };
 }
 
-function linkSkills() {
+function linkSkills(rootDir, options = {}) {
   const { config, configPath, exists, error } = readSkillsConfig(rootDir);
   if (error) {
     console.error(
@@ -250,7 +330,7 @@ function linkSkills() {
     return 1;
   }
 
-  const target = resolveTarget(config);
+  const target = resolveTarget(config, rootDir);
   if (!ensureTarget(target)) {
     return 1;
   }
@@ -260,6 +340,9 @@ function linkSkills() {
     configPath,
     exists,
     target,
+    rootDir,
+    linkRoot: options.linkRoot,
+    explicitTools: options.explicitTools,
   });
   if (mappingError) {
     return 1;
@@ -272,7 +355,6 @@ function linkSkills() {
   return 0;
 }
 
-const exitCode = linkSkills();
-if (exitCode) {
-  process.exit(exitCode);
-}
+module.exports = {
+  linkSkills,
+};