skills-script 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 youzi
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,52 @@
+# skills-script
+
+Interactive skills toolkit CLI.
+
+## Run
+
+```bash
+npx skills-script
+```
+
+Flow:
+
+1. Select tool (currently: `skills-sync`).
+2. Select platforms with Space (multi-select).
+3. Press Enter to confirm.
+4. Optional: input custom platform path tokens (for example: `.aaa`).
+
+## Platform Selection
+
+Built-in options:
+
+- `all`
+- `claude`
+- `codex`
+- `gemini`
+
+Custom token rules:
+
+- `.aaa` => `~/.aaa/skills`
+- absolute/relative path => used directly as target directory
+
+## Source Skills Directory
+
+The source is fixed to:
+
+```bash
+<current_working_directory>/.agents/skills
+```
+
+## Non-Interactive Mode
+
+```bash
+npx skills-script sync claude,codex,.aaa
+```
+
+## Publish
+
+```bash
+cd /Users/youzi/Desktop/__yz/skills-script
+npm login
+npm publish --access public
+```

package/bin/skill-script.js

@@ -0,0 +1,11 @@
+#!/usr/bin/env node
+import { runCli } from '../src/cli.js';
+
+runCli(process.argv.slice(2))
+  .then((code) => {
+    process.exit(code ?? 0);
+  })
+  .catch((error) => {
+    console.error('[ERROR]', error?.message || error);
+    process.exit(1);
+  });

package/package.json

@@ -0,0 +1,32 @@
+{
+  "name": "skills-script",
+  "version": "1.0.0",
+  "description": "Interactive skills toolkit CLI",
+  "type": "module",
+  "bin": {
+    "skill-script": "./bin/skill-script.js",
+    "skills-script": "./bin/skill-script.js"
+  },
+  "files": [
+    "bin",
+    "src",
+    "README.md",
+    "LICENSE"
+  ],
+  "keywords": [
+    "skills",
+    "sync",
+    "cli",
+    "interactive",
+    "claude",
+    "codex",
+    "gemini"
+  ],
+  "engines": {
+    "node": ">=18"
+  },
+  "license": "MIT",
+  "publishConfig": {
+    "access": "public"
+  }
+}

package/src/cli.js

@@ -0,0 +1,45 @@
+import { createRequire } from 'node:module';
+import { runSyncCommand } from './commands/sync.js';
+import { runInteractive } from './commands/interactive.js';
+
+const require = createRequire(import.meta.url);
+const { version } = require('../package.json');
+
+function printUsage() {
+  console.log('skill-script: skills toolkit CLI');
+  console.log('');
+  console.log('Interactive:');
+  console.log('  skill-script');
+  console.log('');
+  console.log('Non-interactive:');
+  console.log('  skill-script sync <platforms>');
+  console.log('');
+  console.log('platforms: all | claude | codex | gemini | custom_path');
+  console.log('example : skill-script sync claude,codex,.aaa');
+}
+
+export async function runCli(argv, { cwd = process.cwd() } = {}) {
+  if (!argv.length) {
+    return runInteractive(cwd);
+  }
+
+  const first = argv[0].toLowerCase();
+
+  if (first === '-h' || first === '--help' || first === 'help') {
+    printUsage();
+    return 0;
+  }
+
+  if (first === '-v' || first === '--version' || first === 'version') {
+    console.log(version);
+    return 0;
+  }
+
+  if (first === 'sync') {
+    return runSyncCommand(argv.slice(1), { cwd });
+  }
+
+  console.error(`[ERROR] Unknown command: ${argv[0]}`);
+  printUsage();
+  return 1;
+}

package/src/commands/interactive.js

@@ -0,0 +1,59 @@
+import path from 'node:path';
+import { multiSelect, promptInput, selectOne } from '../lib/interactive.js';
+import { resolveTargetDirs, runSyncByTargets } from './sync.js';
+
+function parseCustomInput(input) {
+  if (!input) return [];
+  return input
+    .split(/[\s,]+/g)
+    .map((s) => s.trim())
+    .filter(Boolean);
+}
+
+export async function runInteractive(cwd = process.cwd()) {
+  const tool = await selectOne({
+    title: 'Select a tool',
+    options: [{ label: 'skills-sync', value: 'skills-sync' }]
+  });
+
+  if (tool !== 'skills-sync') {
+    console.error('[ERROR] Unsupported tool selected.');
+    return 1;
+  }
+
+  const selected = await multiSelect({
+    title: 'Select target platforms (multi-select)',
+    options: [
+      { label: 'all', value: 'all' },
+      { label: 'claude', value: 'claude' },
+      { label: 'codex', value: 'codex' },
+      { label: 'gemini', value: 'gemini' },
+      { label: 'custom path', value: 'custom' }
+    ]
+  });
+
+  if (!selected.length) {
+    console.error('[ERROR] No platform selected.');
+    return 1;
+  }
+
+  const tokens = selected.filter((item) => item !== 'custom');
+
+  if (selected.includes('custom')) {
+    // First read may consume trailing Enter from the multi-select confirm key.
+    let customRaw = await promptInput(
+      'Input custom platform path tokens (space/comma separated). Example: .aaa ~/.bbb/skills'
+    );
+
+    if (!customRaw) {
+      customRaw = await promptInput('Input custom platform path (press Enter to skip)');
+    }
+
+    tokens.push(...parseCustomInput(customRaw));
+  }
+
+  const sourceDir = path.join(cwd, '.agents', 'skills');
+  const targetDirs = resolveTargetDirs({ platformTokens: tokens, cwd });
+
+  return runSyncByTargets({ sourceDir, targetDirs });
+}

package/src/commands/sync.js

@@ -0,0 +1,187 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { expandHome, resolveCustomTarget, sameOrSubPath } from '../lib/path-utils.js';
+
+export const PLATFORM_TARGETS = {
+  codex: '~/.codex/skills',
+  claude: '~/.claude/skills',
+  gemini: '~/.gemini/skills'
+};
+
+function splitTokens(input) {
+  return input
+    .split(/[\s,]+/g)
+    .map((s) => s.trim())
+    .filter(Boolean);
+}
+
+function dedupePaths(paths) {
+  const seen = new Set();
+  const result = [];
+
+  for (const item of paths) {
+    const abs = path.resolve(item);
+    if (seen.has(abs)) continue;
+    seen.add(abs);
+    result.push(abs);
+  }
+
+  return result;
+}
+
+export function resolveTargetDirs({ platformTokens, cwd }) {
+  const targets = [];
+
+  const addNamed = (name) => {
+    targets.push(expandHome(PLATFORM_TARGETS[name]));
+  };
+
+  for (const tokenRaw of platformTokens) {
+    if (typeof tokenRaw !== 'string') {
+      continue;
+    }
+
+    const token = tokenRaw.trim();
+    if (!token) continue;
+
+    const lower = token.toLowerCase();
+    if (lower === 'all') {
+      addNamed('claude');
+      addNamed('codex');
+      addNamed('gemini');
+      continue;
+    }
+
+    if (PLATFORM_TARGETS[lower]) {
+      addNamed(lower);
+      continue;
+    }
+
+    const custom = resolveCustomTarget(token, cwd);
+    if (custom) targets.push(custom);
+  }
+
+  return dedupePaths(targets);
+}
+
+async function listSkillDirs(sourceDir) {
+  const entries = await fs.readdir(sourceDir, { withFileTypes: true });
+  return entries
+    .filter((entry) => entry.isDirectory() && !entry.name.startsWith('.'))
+    .map((entry) => ({
+      name: entry.name,
+      fullPath: path.join(sourceDir, entry.name)
+    }))
+    .sort((a, b) => a.name.localeCompare(b.name));
+}
+
+async function syncTarget(sourceDir, sourceReal, targetDir) {
+  await fs.mkdir(targetDir, { recursive: true });
+
+  const skills = await listSkillDirs(sourceDir);
+  const skillNames = new Set(skills.map((s) => s.name));
+
+  let linked = 0;
+  let skipped = 0;
+  let removed = 0;
+
+  for (const skill of skills) {
+    const linkPath = path.join(targetDir, skill.name);
+
+    try {
+      const stat = await fs.lstat(linkPath);
+      if (!stat.isSymbolicLink()) {
+        console.warn(`[WARN] Skip existing non-symlink: ${linkPath}`);
+        skipped += 1;
+        continue;
+      }
+      await fs.unlink(linkPath);
+    } catch (error) {
+      if (error && error.code !== 'ENOENT') throw error;
+    }
+
+    await fs.symlink(skill.fullPath, linkPath);
+    linked += 1;
+  }
+
+  const sourceResolved = path.resolve(sourceDir);
+  const targetEntries = await fs.readdir(targetDir, { withFileTypes: true });
+
+  for (const entry of targetEntries) {
+    if (!entry.isSymbolicLink()) continue;
+    if (skillNames.has(entry.name)) continue;
+
+    const fullPath = path.join(targetDir, entry.name);
+
+    let rawLinkTarget;
+    try {
+      rawLinkTarget = await fs.readlink(fullPath);
+    } catch {
+      continue;
+    }
+
+    const linkTargetAbsolute = path.isAbsolute(rawLinkTarget)
+      ? rawLinkTarget
+      : path.resolve(targetDir, rawLinkTarget);
+
+    if (
+      sameOrSubPath(linkTargetAbsolute, sourceResolved) ||
+      sameOrSubPath(linkTargetAbsolute, sourceReal)
+    ) {
+      await fs.unlink(fullPath);
+      removed += 1;
+    }
+  }
+
+  console.log(`[OK] ${targetDir} -> linked:${linked} skipped:${skipped} removed-stale:${removed}`);
+}
+
+export async function runSyncByTargets({ sourceDir, targetDirs }) {
+  if (!targetDirs.length) {
+    console.error('[ERROR] No target platform/path selected.');
+    return 1;
+  }
+
+  let sourceStat;
+  try {
+    sourceStat = await fs.stat(sourceDir);
+  } catch {
+    console.error(`[ERROR] Source skill directory not found: ${sourceDir}`);
+    return 1;
+  }
+
+  if (!sourceStat.isDirectory()) {
+    console.error(`[ERROR] Source is not a directory: ${sourceDir}`);
+    return 1;
+  }
+
+  const sourceReal = await fs.realpath(sourceDir);
+
+  console.log(`[INFO] Source: ${sourceDir}`);
+  for (const targetDir of targetDirs) {
+    await syncTarget(sourceDir, sourceReal, targetDir);
+  }
+
+  console.log('[DONE] Skill symlink sync complete');
+  return 0;
+}
+
+export async function runSyncCommand(args, { cwd = process.cwd() } = {}) {
+  // Non-interactive mode: sync <platforms>
+  // Examples: sync claude
+  //           sync all
+  //           sync claude,codex,.aaa
+  const joined = args.join(' ');
+  const tokens = splitTokens(joined);
+
+  if (!tokens.length) {
+    console.log('Usage: skill-script sync <platforms>');
+    console.log('platforms: all | claude | codex | gemini | custom_path');
+    console.log('example: skill-script sync claude,codex,.aaa');
+    return 1;
+  }
+
+  const sourceDir = path.join(cwd, '.agents', 'skills');
+  const targetDirs = resolveTargetDirs({ platformTokens: tokens, cwd });
+  return runSyncByTargets({ sourceDir, targetDirs });
+}

package/src/lib/interactive.js

@@ -0,0 +1,161 @@
+import readline from 'node:readline';
+import { createInterface } from 'node:readline/promises';
+import process from 'node:process';
+
+function ensureTty() {
+  if (!process.stdin.isTTY || !process.stdout.isTTY) {
+    throw new Error('Interactive mode requires a TTY terminal.');
+  }
+}
+
+function clearScreen() {
+  process.stdout.write('\x1Bc');
+}
+
+function normalizeEnter(key) {
+  return key?.name === 'return' || key?.name === 'enter';
+}
+
+export async function selectOne({ title, options }) {
+  ensureTty();
+
+  let cursor = 0;
+
+  return new Promise((resolve, reject) => {
+    const cleanup = () => {
+      process.stdin.off('keypress', onKeyPress);
+      process.stdin.setRawMode(false);
+      process.stdin.pause();
+    };
+
+    const render = () => {
+      clearScreen();
+      console.log(title);
+      console.log('Use Up/Down to move, Enter to confirm.');
+      console.log('');
+      options.forEach((item, index) => {
+        const pointer = index === cursor ? '>' : ' ';
+        console.log(`${pointer} ${item.label}`);
+      });
+    };
+
+    const onKeyPress = (_str, key = {}) => {
+      if (key.ctrl && key.name === 'c') {
+        cleanup();
+        process.stdout.write('\n');
+        reject(new Error('Canceled by user.'));
+        return;
+      }
+
+      if (key.name === 'up') {
+        cursor = (cursor - 1 + options.length) % options.length;
+        render();
+        return;
+      }
+
+      if (key.name === 'down') {
+        cursor = (cursor + 1) % options.length;
+        render();
+        return;
+      }
+
+      if (normalizeEnter(key)) {
+        const selected = options[cursor];
+        cleanup();
+        clearScreen();
+        resolve(selected.value);
+      }
+    };
+
+    readline.emitKeypressEvents(process.stdin);
+    process.stdin.setRawMode(true);
+    process.stdin.resume();
+    process.stdin.on('keypress', onKeyPress);
+    render();
+  });
+}
+
+export async function multiSelect({ title, options }) {
+  ensureTty();
+
+  let cursor = 0;
+  const selected = new Set();
+
+  return new Promise((resolve, reject) => {
+    const cleanup = () => {
+      process.stdin.off('keypress', onKeyPress);
+      process.stdin.setRawMode(false);
+      process.stdin.pause();
+    };
+
+    const render = () => {
+      clearScreen();
+      console.log(title);
+      console.log('Use Up/Down to move, Space to select, Enter to confirm.');
+      console.log('');
+      options.forEach((item, index) => {
+        const pointer = index === cursor ? '>' : ' ';
+        const mark = selected.has(item.value) ? '[x]' : '[ ]';
+        console.log(`${pointer} ${mark} ${item.label}`);
+      });
+    };
+
+    const onKeyPress = (_str, key = {}) => {
+      if (key.ctrl && key.name === 'c') {
+        cleanup();
+        process.stdout.write('\n');
+        reject(new Error('Canceled by user.'));
+        return;
+      }
+
+      if (key.name === 'up') {
+        cursor = (cursor - 1 + options.length) % options.length;
+        render();
+        return;
+      }
+
+      if (key.name === 'down') {
+        cursor = (cursor + 1) % options.length;
+        render();
+        return;
+      }
+
+      if (key.name === 'space') {
+        const current = options[cursor].value;
+        if (selected.has(current)) {
+          selected.delete(current);
+        } else {
+          selected.add(current);
+        }
+        render();
+        return;
+      }
+
+      if (normalizeEnter(key)) {
+        cleanup();
+        clearScreen();
+        resolve(Array.from(selected));
+      }
+    };
+
+    readline.emitKeypressEvents(process.stdin);
+    process.stdin.setRawMode(true);
+    process.stdin.resume();
+    process.stdin.on('keypress', onKeyPress);
+    render();
+  });
+}
+
+export async function promptInput(message) {
+  const rl = createInterface({
+    input: process.stdin,
+    output: process.stdout
+  });
+
+  try {
+    const answer = await rl.question(`${message}\n> `);
+    return typeof answer === 'string' ? answer.trim() : '';
+  } finally {
+    rl.close();
+  }
+}

package/src/lib/path-utils.js

@@ -0,0 +1,35 @@
+import path from 'node:path';
+import os from 'node:os';
+
+export function expandHome(inputPath) {
+  if (!inputPath) return inputPath;
+  if (inputPath === '~') return os.homedir();
+  if (inputPath.startsWith('~/')) return path.join(os.homedir(), inputPath.slice(2));
+  return inputPath;
+}
+
+export function sameOrSubPath(childPath, parentPath) {
+  const child = path.resolve(childPath);
+  const parent = path.resolve(parentPath);
+  if (child === parent) return true;
+  const relative = path.relative(parent, child);
+  return relative !== '' && !relative.startsWith('..') && !path.isAbsolute(relative);
+}
+
+export function resolveCustomTarget(token, cwd) {
+  const raw = token.trim();
+  if (!raw) return null;
+
+  // .aaa -> ~/.aaa/skills
+  if (raw.startsWith('.') && !raw.startsWith('./') && !raw.startsWith('../')) {
+    return path.join(os.homedir(), raw, 'skills');
+  }
+
+  const expanded = expandHome(raw);
+
+  if (path.isAbsolute(expanded)) {
+    return expanded;
+  }
+
+  return path.resolve(cwd, expanded);
+}