mymskills 1.0.0

package/bin/mymskills.js

@@ -0,0 +1,15 @@
+#!/usr/bin/env node
+
+const nodeVersion = parseInt(process.versions.node.split('.')[0], 10);
+if (nodeVersion < 18) {
+  console.error(`mymskills requires Node.js 18 or later. You are running Node.js ${process.versions.node}.`);
+  process.exit(1);
+}
+
+import { createProgram } from '../lib/cli.js';
+
+const program = createProgram();
+program.parseAsync(process.argv).catch((error) => {
+  process.stderr.write(`\nError: ${error.message}\n`);
+  process.exit(1);
+});

package/lib/cli.js

@@ -0,0 +1,33 @@
+import { Command } from 'commander';
+import { VERSION } from './constants.js';
+import { installCommand } from './commands/install.js';
+import { updateCommand } from './commands/update.js';
+import { removeCommand } from './commands/remove.js';
+import { listCommand } from './commands/list.js';
+
+export function createProgram() {
+  const program = new Command();
+
+  program
+    .name('mymskills')
+    .description('Interactive installer for mymediset AI skills')
+    .version(VERSION, '-v, --version')
+    .action(installCommand);
+
+  program
+    .command('update')
+    .description('Update installed skills to the latest version')
+    .action(updateCommand);
+
+  program
+    .command('remove')
+    .description('Remove installed skills')
+    .action(removeCommand);
+
+  program
+    .command('list')
+    .description('List installed and available skills')
+    .action(listCommand);
+
+  return program;
+}

package/lib/commands/install.js

@@ -0,0 +1,116 @@
+import ora from 'ora';
+import chalk from 'chalk';
+import boxen from 'boxen';
+import { showBanner } from '../ui/banner.js';
+import { promptSkillSelection, promptPlatform, promptScope, promptMode, promptConfirm } from '../ui/prompts.js';
+import { fetchSkillSource } from '../core/fetcher.js';
+import { buildCatalog } from '../core/registry.js';
+import { installSkill } from '../core/installer.js';
+import { getSkillsDir } from '../core/paths.js';
+import { PLATFORMS } from '../constants.js';
+import path from 'node:path';
+
+export async function installCommand() {
+  showBanner();
+
+  const { sourceDir, catalog } = await fetchCatalog();
+
+  const selectedNames = await promptSkillSelection(catalog);
+  const platforms = await promptPlatform();
+  const scope = await promptScope();
+  const mode = await promptMode();
+
+  const summary = buildSummary(selectedNames, platforms, scope, mode);
+  console.log(summary);
+
+  const proceed = await promptConfirm('Proceed with installation?');
+  if (!proceed) {
+    console.log(chalk.yellow('\nInstallation cancelled.'));
+    return;
+  }
+
+  const results = executeInstalls(sourceDir, selectedNames, platforms, scope, mode);
+
+  if (results.length > 0) {
+    printSuccess(results, scope);
+  }
+}
+
+async function fetchCatalog() {
+  const spinner = ora('Fetching skill catalog...').start();
+  let sourceDir;
+  try {
+    sourceDir = await fetchSkillSource(spinner);
+  } catch (error) {
+    spinner.fail(error.message);
+    process.exit(1);
+  }
+
+  const catalog = buildCatalog(path.join(sourceDir, 'skills'));
+  if (catalog.length === 0) {
+    spinner.fail('No skills found in the library.');
+    process.exit(1);
+  }
+  spinner.succeed(`Found ${catalog.length} skills`);
+  return { sourceDir, catalog };
+}
+
+function executeInstalls(sourceDir, selectedNames, platforms, scope, mode) {
+  console.log('');
+  const results = [];
+
+  for (const platformKey of platforms) {
+    const targetDir = getSkillsDir(platformKey, scope);
+
+    for (const skillDirName of selectedNames) {
+      const skillSpinner = ora(`Installing ${skillDirName} to ${PLATFORMS[platformKey].name}...`).start();
+      try {
+        const result = installSkill(sourceDir, targetDir, skillDirName, mode);
+        results.push({ ...result, platform: PLATFORMS[platformKey].name });
+        skillSpinner.succeed(`${skillDirName} ${chalk.dim(`(${result.mode})`)}`);
+      } catch (error) {
+        skillSpinner.fail(`${skillDirName}: ${error.message}`);
+      }
+    }
+  }
+
+  return results;
+}
+
+function buildSummary(skills, platforms, scope, mode) {
+  const lines = [
+    chalk.bold('Installation Summary'),
+    '',
+    `  Skills:    ${skills.map(s => chalk.cyan(s)).join(', ')}`,
+    `  Platform:  ${platforms.map(p => PLATFORMS[p].name).join(', ')}`,
+    `  Scope:     ${scope}`,
+    `  Mode:      ${mode}`,
+  ];
+
+  return boxen(lines.join('\n'), {
+    padding: { top: 0, bottom: 0, left: 1, right: 1 },
+    margin: { top: 1, bottom: 0, left: 0, right: 0 },
+    borderStyle: 'round',
+    borderColor: 'cyan',
+  });
+}
+
+function printSuccess(results, scope) {
+  console.log('');
+  console.log(chalk.green.bold('  Installation complete!'));
+  console.log('');
+
+  for (const r of results) {
+    console.log(`  ${chalk.green('\u2713')} ${r.name} \u2192 ${r.platform} ${chalk.dim(`(${r.mode})`)}`);
+  }
+
+  console.log('');
+  if (scope === 'project') {
+    console.log(chalk.dim('  Start a coding session in this directory \u2014 skills activate automatically.'));
+  } else {
+    console.log(chalk.dim('  Skills installed globally \u2014 available in all projects.'));
+  }
+
+  console.log(chalk.dim('  Run `npx mymskills update` to pull the latest skill content.'));
+  console.log('');
+}

package/lib/commands/list.js

@@ -0,0 +1,55 @@
+import chalk from 'chalk';
+import { showMiniBanner } from '../ui/banner.js';
+import { detectInstalledSkills } from '../core/detector.js';
+import { buildCatalog } from '../core/registry.js';
+import { getCacheDir } from '../core/paths.js';
+import path from 'node:path';
+import fs from 'node:fs';
+
+export async function listCommand() {
+  showMiniBanner();
+
+  const installed = detectInstalledSkills({ prefix: 'mymediset-' });
+
+  if (installed.length > 0) {
+    console.log(chalk.bold('  Installed Skills'));
+    console.log(chalk.dim('  ' + '\u2500'.repeat(60)));
+
+    for (const skill of installed) {
+      console.log(
+        `  ${chalk.green('\u2713')} ${chalk.bold(skill.name)}  ` +
+        `${chalk.dim(skill.platformName)} \u00b7 ${chalk.dim(skill.scope)} \u00b7 ${chalk.dim(skill.mode)}`
+      );
+    }
+    console.log('');
+  } else {
+    console.log(chalk.dim('  No skills installed.\n'));
+  }
+
+  const cacheDir = getCacheDir();
+  const skillsDir = path.join(cacheDir, 'skills');
+
+  if (fs.existsSync(skillsDir)) {
+    const catalog = buildCatalog(skillsDir);
+    const installedNames = new Set(installed.map(s => s.name));
+    const available = catalog
+      .filter(s => s.dirName.startsWith('mymediset-'))
+      .filter(s => !installedNames.has(s.dirName));
+
+    if (available.length > 0) {
+      console.log(chalk.bold('  Available Skills'));
+      console.log(chalk.dim('  ' + '\u2500'.repeat(60)));
+
+      for (const skill of available) {
+        console.log(
+          `  ${chalk.dim('\u25cb')} ${skill.name}  ` +
+          chalk.dim(`${skill.refCount} references`)
+        );
+      }
+      console.log('');
+      console.log(chalk.dim('  Run `npx mymskills` to install.\n'));
+    }
+  } else {
+    console.log(chalk.dim('  Run `npx mymskills` to fetch the skill catalog.\n'));
+  }
+}

package/lib/commands/remove.js

@@ -0,0 +1,43 @@
+import chalk from 'chalk';
+import { showMiniBanner } from '../ui/banner.js';
+import { detectInstalledSkills } from '../core/detector.js';
+import { removeSkill } from '../core/installer.js';
+import { promptRemoveSelection, promptConfirm } from '../ui/prompts.js';
+
+export async function removeCommand() {
+  showMiniBanner();
+
+  const installed = detectInstalledSkills({ prefix: 'mymediset-' });
+  if (installed.length === 0) {
+    console.log(chalk.yellow('  No mymediset skills installed.\n'));
+    return;
+  }
+
+  const toRemove = await promptRemoveSelection(installed);
+  if (toRemove.length === 0) return;
+
+  console.log('');
+  const proceed = await promptConfirm(
+    `Remove ${toRemove.length} skill(s)? This cannot be undone.`
+  );
+  if (!proceed) {
+    console.log(chalk.yellow('\n  Removal cancelled.\n'));
+    return;
+  }
+
+  console.log('');
+  let removed = 0;
+
+  for (const skill of toRemove) {
+    const success = removeSkill(skill.path);
+    if (success) {
+      console.log(`  ${chalk.red('\u2717')} Removed ${skill.name} ${chalk.dim(`from ${skill.platformName} (${skill.scope})`)}`);
+      removed++;
+    } else {
+      console.log(`  ${chalk.yellow('!')} ${skill.name} not found at ${skill.path}`);
+    }
+  }
+
+  console.log('');
+  console.log(chalk.green(`  ${removed} skill(s) removed.\n`));
+}

package/lib/commands/update.js

@@ -0,0 +1,65 @@
+import ora from 'ora';
+import chalk from 'chalk';
+import { showMiniBanner } from '../ui/banner.js';
+import { fetchSkillSource } from '../core/fetcher.js';
+import { detectInstalledSkills } from '../core/detector.js';
+import { installSkill } from '../core/installer.js';
+import path from 'node:path';
+
+export async function updateCommand() {
+  showMiniBanner();
+
+  const installed = detectInstalledSkills({ prefix: 'mymediset-' });
+  if (installed.length === 0) {
+    console.log(chalk.yellow('  No mymediset skills installed. Run `npx mymskills` to install.\n'));
+    return;
+  }
+
+  console.log(`  Found ${installed.length} installed skill(s)\n`);
+
+  const spinner = ora('Pulling latest skill library...').start();
+  let sourceDir;
+  try {
+    sourceDir = await fetchSkillSource(spinner);
+    spinner.succeed('Skill library updated');
+  } catch (error) {
+    spinner.fail(error.message);
+    process.exit(1);
+  }
+
+  const { updated, skipped } = applyUpdates(installed, sourceDir);
+
+  console.log('');
+  if (updated > 0) {
+    console.log(chalk.green(`  ${updated} skill(s) updated.`));
+  }
+  if (skipped > 0) {
+    console.log(chalk.dim(`  ${skipped} symlinked skill(s) already up to date.`));
+  }
+  console.log('');
+}
+
+function applyUpdates(installed, sourceDir) {
+  let updated = 0;
+  let skipped = 0;
+
+  for (const skill of installed) {
+    if (skill.mode === 'symlink') {
+      console.log(`  ${chalk.green('\u2713')} ${skill.name} ${chalk.dim('(symlink \u2014 already points to latest)')}`);
+      skipped++;
+      continue;
+    }
+
+    const skillSpinner = ora(`Updating ${skill.name}...`).start();
+    try {
+      const targetDir = path.dirname(skill.path);
+      installSkill(sourceDir, targetDir, skill.name, 'copy');
+      skillSpinner.succeed(`${skill.name} ${chalk.dim('(re-copied)')}`);
+      updated++;
+    } catch (error) {
+      skillSpinner.fail(`${skill.name}: ${error.message}`);
+    }
+  }
+
+  return { updated, skipped };
+}

package/lib/constants.js

@@ -0,0 +1,21 @@
+import { createRequire } from 'node:module';
+import { fileURLToPath } from 'node:url';
+import path from 'node:path';
+
+const require = createRequire(import.meta.url);
+const pkg = require('../package.json');
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+export const VERSION = pkg.version;
+export const GH_REPO = 'BITASIA/mym-sap-skill';
+export const GH_CLONE_URL = `https://github.com/${GH_REPO}.git`;
+export const CACHE_DIR_NAME = '.mym-sap-skills';
+export const INSTALLER_ROOT = path.resolve(__dirname, '..');
+export const SKILL_PREFIX = 'mymediset-';
+
+export const PLATFORMS = {
+  claude: { name: 'Claude Code', dir: '.claude/skills' },
+  cursor: { name: 'Cursor', dir: '.cursor/skills' },
+};

package/lib/core/detector.js

@@ -0,0 +1,52 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { getAllScanLocations } from './paths.js';
+import { PLATFORMS } from '../constants.js';
+
+export function detectInstalledSkills({ prefix } = {}) {
+  const locations = getAllScanLocations();
+  const installed = [];
+
+  for (const loc of locations) {
+    if (!fs.existsSync(loc.path)) continue;
+
+    let entries;
+    try {
+      entries = fs.readdirSync(loc.path, { withFileTypes: true });
+    } catch {
+      continue;
+    }
+
+    for (const entry of entries) {
+      const fullPath = path.join(loc.path, entry.name);
+      const skillMdPath = path.join(fullPath, 'SKILL.md');
+      const isLink = isSymlink(fullPath);
+
+      const hasSkillMd = isLink
+        ? fs.existsSync(skillMdPath)
+        : entry.isDirectory() && fs.existsSync(skillMdPath);
+
+      if (!hasSkillMd) continue;
+      if (prefix && !entry.name.startsWith(prefix)) continue;
+
+      installed.push({
+        name: entry.name,
+        path: fullPath,
+        scope: loc.scope,
+        platform: loc.platform,
+        platformName: PLATFORMS[loc.platform].name,
+        mode: isLink ? 'symlink' : 'copy',
+      });
+    }
+  }
+
+  return installed;
+}
+
+function isSymlink(filePath) {
+  try {
+    return fs.lstatSync(filePath).isSymbolicLink();
+  } catch {
+    return false;
+  }
+}

package/lib/core/fetcher.js

@@ -0,0 +1,72 @@
+import { execFileSync } from 'node:child_process';
+import fs from 'node:fs';
+import path from 'node:path';
+import { GH_CLONE_URL } from '../constants.js';
+import { getCacheDir } from './paths.js';
+
+function gitAvailable() {
+  try {
+    execFileSync('git', ['--version'], { stdio: 'ignore' });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function isInsideRepo() {
+  const installerRoot = path.resolve(new URL('..', import.meta.url).pathname);
+  const repoRoot = path.resolve(installerRoot, '..');
+  const skillsDir = path.join(repoRoot, 'skills');
+  const readme = path.join(repoRoot, 'README.md');
+
+  return fs.existsSync(skillsDir) && fs.existsSync(readme) ? repoRoot : null;
+}
+
+export async function fetchSkillSource(spinner) {
+  const localRepo = isInsideRepo();
+  if (localRepo) {
+    spinner.text = 'Using local skill library...';
+    if (fs.existsSync(path.join(localRepo, '.git'))) {
+      try {
+        execFileSync('git', ['pull', '--ff-only', '--quiet'], { cwd: localRepo, stdio: 'ignore' });
+        spinner.text = 'Local skill library updated';
+      } catch {
+        spinner.text = 'Using cached local version';
+      }
+    }
+    return localRepo;
+  }
+
+  const cacheDir = getCacheDir();
+
+  if (fs.existsSync(path.join(cacheDir, '.git'))) {
+    spinner.text = 'Updating skill library...';
+    try {
+      execFileSync('git', ['pull', '--ff-only', '--quiet'], { cwd: cacheDir, stdio: 'ignore' });
+    } catch {
+      spinner.text = 'Using cached version';
+    }
+    return cacheDir;
+  }
+
+  if (!gitAvailable()) {
+    throw new Error(
+      'git is required but not found.\n' +
+      'Install git and ensure you have access to the mymediset skill repository.\n' +
+      `Alternatively, clone manually: git clone ${GH_CLONE_URL} ${cacheDir}`
+    );
+  }
+
+  spinner.text = 'Downloading skill library...';
+  try {
+    execFileSync('git', ['clone', '--depth', '1', GH_CLONE_URL, cacheDir], { stdio: 'ignore' });
+  } catch {
+    throw new Error(
+      'Failed to clone the skill repository.\n' +
+      'Ensure you have access to the repository and your git credentials are configured.\n' +
+      `Repository: ${GH_CLONE_URL}`
+    );
+  }
+
+  return cacheDir;
+}

package/lib/core/installer.js

@@ -0,0 +1,90 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import os from 'node:os';
+import { PLATFORMS } from '../constants.js';
+
+const VALID_SKILL_NAME = /^[a-zA-Z0-9_-]+$/;
+
+function validateSkillName(name) {
+  if (!VALID_SKILL_NAME.test(name)) {
+    throw new Error(`Invalid skill name: "${name}" — names may only contain letters, numbers, hyphens, and underscores`);
+  }
+}
+
+function assertPathContained(child, parent) {
+  const resolvedChild = path.resolve(child);
+  const resolvedParent = path.resolve(parent);
+  if (!resolvedChild.startsWith(resolvedParent + path.sep)) {
+    throw new Error(`Path traversal detected: "${child}" escapes expected directory "${parent}"`);
+  }
+}
+
+function getValidSkillParents() {
+  const home = os.homedir();
+  const parents = [];
+  for (const platform of Object.values(PLATFORMS)) {
+    parents.push(path.join(home, platform.dir));
+    parents.push(path.join(process.cwd(), platform.dir));
+  }
+  return parents;
+}
+
+export function installSkill(sourceDir, targetDir, skillDirName, mode) {
+  validateSkillName(skillDirName);
+
+  const source = path.resolve(sourceDir, 'skills', skillDirName);
+  if (!fs.existsSync(source)) {
+    throw new Error(`Skill source not found: ${source}`);
+  }
+
+  const target = path.join(targetDir, skillDirName);
+  assertPathContained(target, targetDir);
+
+  fs.mkdirSync(targetDir, { recursive: true });
+
+  if (fs.existsSync(target)) {
+    const stat = fs.lstatSync(target);
+    if (stat.isSymbolicLink()) {
+      fs.unlinkSync(target);
+    } else {
+      fs.rmSync(target, { recursive: true });
+    }
+  }
+
+  const effectiveMode = resolveMode(mode);
+
+  if (effectiveMode === 'symlink') {
+    fs.symlinkSync(source, target, 'dir');
+  } else {
+    fs.cpSync(source, target, { recursive: true });
+  }
+
+  return { name: skillDirName, target, mode: effectiveMode };
+}
+
+function resolveMode(requestedMode) {
+  if (requestedMode === 'copy') return 'copy';
+  if (os.platform() === 'win32') return 'copy';
+  return 'symlink';
+}
+
+export function removeSkill(skillPath) {
+  if (!fs.existsSync(skillPath)) return false;
+
+  const normalized = path.resolve(skillPath);
+  const validParents = getValidSkillParents();
+  const isInside = validParents.some(
+    (parent) => normalized.startsWith(parent + path.sep)
+  );
+  if (!isInside) {
+    throw new Error(`Refusing to remove path outside skills directories: ${skillPath}`);
+  }
+
+  const stat = fs.lstatSync(skillPath);
+  if (stat.isSymbolicLink()) {
+    fs.unlinkSync(skillPath);
+  } else {
+    fs.rmSync(skillPath, { recursive: true });
+  }
+  return true;
+}

package/lib/core/paths.js

@@ -0,0 +1,29 @@
+import path from 'node:path';
+import os from 'node:os';
+import { PLATFORMS, CACHE_DIR_NAME } from '../constants.js';
+
+export function getCacheDir() {
+  return path.join(os.homedir(), CACHE_DIR_NAME);
+}
+
+export function getSkillsDir(platform, scope) {
+  const base = scope === 'global' ? os.homedir() : process.cwd();
+  return path.join(base, PLATFORMS[platform].dir);
+}
+
+export function getAllScanLocations() {
+  const locations = [];
+  for (const [platformKey, platformConfig] of Object.entries(PLATFORMS)) {
+    locations.push({
+      path: path.join(os.homedir(), platformConfig.dir),
+      scope: 'global',
+      platform: platformKey,
+    });
+    locations.push({
+      path: path.join(process.cwd(), platformConfig.dir),
+      scope: 'project',
+      platform: platformKey,
+    });
+  }
+  return locations;
+}

package/lib/core/registry.js

@@ -0,0 +1,78 @@
+import fs from 'node:fs';
+import path from 'node:path';
+
+export function parseSkillFrontmatter(skillMdPath) {
+  const content = fs.readFileSync(skillMdPath, 'utf-8');
+  const match = content.match(/^---\n([\s\S]*?)\n---/);
+  if (!match) return null;
+
+  const frontmatter = match[1];
+  const name = extractField(frontmatter, 'name');
+  const description = extractDescription(frontmatter);
+
+  return { name, description };
+}
+
+function extractField(text, field) {
+  const escaped = field.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+  const match = text.match(new RegExp(`^${escaped}:\\s*(.+)$`, 'm'));
+  return match ? match[1].trim().replace(/^["']|["']$/g, '') : '';
+}
+
+function extractDescription(text) {
+  const lines = text.split('\n');
+  let capturing = false;
+  const parts = [];
+
+  for (const line of lines) {
+    if (line.match(/^description:/)) {
+      const inline = line.replace(/^description:\s*>?\s*/, '').trim();
+      if (inline && !inline.startsWith('>')) {
+        return inline.replace(/^["']|["']$/g, '');
+      }
+      capturing = true;
+      continue;
+    }
+    if (capturing) {
+      if (line.match(/^\S/)) break;
+      parts.push(line.trim());
+    }
+  }
+
+  return parts.join(' ').trim().replace(/^["']|["']$/g, '');
+}
+
+export function buildCatalog(skillsDir) {
+  if (!fs.existsSync(skillsDir)) return [];
+
+  const entries = fs.readdirSync(skillsDir, { withFileTypes: true });
+  const catalog = [];
+
+  for (const entry of entries) {
+    if (!entry.isDirectory()) continue;
+
+    const skillPath = path.join(skillsDir, entry.name);
+    const skillMdPath = path.join(skillPath, 'SKILL.md');
+
+    if (!fs.existsSync(skillMdPath)) continue;
+
+    const meta = parseSkillFrontmatter(skillMdPath);
+    if (!meta) continue;
+
+    const refsDir = path.join(skillPath, 'references');
+    let refCount = 0;
+    if (fs.existsSync(refsDir)) {
+      refCount = fs.readdirSync(refsDir).filter(f => f.endsWith('.md')).length;
+    }
+
+    catalog.push({
+      name: meta.name || entry.name,
+      dirName: entry.name,
+      description: meta.description,
+      refCount,
+      path: skillPath,
+    });
+  }
+
+  return catalog.sort((a, b) => a.name.localeCompare(b.name));
+}

package/lib/ui/banner.js

@@ -0,0 +1,36 @@
+import figlet from 'figlet';
+import gradient from 'gradient-string';
+import boxen from 'boxen';
+import chalk from 'chalk';
+import { VERSION } from '../constants.js';
+
+const COOL_GRADIENT = gradient(['#00b4d8', '#0077b6', '#6c63ff', '#e040fb']);
+
+export function showBanner() {
+  const ascii = figlet.textSync('mymskills', {
+    font: 'Small',
+    horizontalLayout: 'default',
+  });
+
+  const banner = COOL_GRADIENT(ascii);
+
+  const tagline = chalk.dim('Interactive installer for mymediset AI skills');
+  const version = chalk.dim(`v${VERSION}`);
+
+  const content = `${banner}\n\n  ${tagline}\n  ${version}`;
+
+  console.log('');
+  console.log(
+    boxen(content, {
+      padding: 1,
+      margin: { top: 0, bottom: 1, left: 2, right: 2 },
+      borderStyle: 'round',
+      borderColor: '#0077b6',
+    })
+  );
+}
+
+export function showMiniBanner() {
+  const title = COOL_GRADIENT('mymskills');
+  console.log(`\n  ${title} ${chalk.dim(`v${VERSION}`)}\n`);
+}

package/lib/ui/prompts.js

@@ -0,0 +1,85 @@
+import { checkbox, select, confirm } from '@inquirer/prompts';
+import chalk from 'chalk';
+import { PLATFORMS } from '../constants.js';
+
+export async function promptSkillSelection(catalog) {
+  const choices = catalog.map(skill => ({
+    name: `${chalk.bold(skill.name)} ${chalk.dim(`(${skill.refCount} references)`)}`,
+    value: skill.dirName,
+    description: truncate(skill.description, 80),
+  }));
+
+  return checkbox({
+    message: 'Select skills to install:',
+    choices,
+    required: true,
+    instructions: chalk.dim('  (space to select, enter to confirm)'),
+  });
+}
+
+export async function promptPlatform() {
+  return select({
+    message: 'Target platform:',
+    choices: [
+      { name: 'Claude Code', value: ['claude'] },
+      { name: 'Cursor', value: ['cursor'] },
+      { name: 'Both', value: ['claude', 'cursor'] },
+    ],
+  });
+}
+
+export async function promptScope() {
+  return select({
+    message: 'Installation scope:',
+    choices: [
+      {
+        name: `Project ${chalk.dim('(./<platform>/skills/ in current directory)')}`,
+        value: 'project',
+      },
+      {
+        name: `Global ${chalk.dim('(~/<platform>/skills/ for all projects)')}`,
+        value: 'global',
+      },
+    ],
+  });
+}
+
+export async function promptMode() {
+  return select({
+    message: 'Installation mode:',
+    choices: [
+      {
+        name: `Symlink ${chalk.dim('(recommended — auto-updates with mymskills update)')}`,
+        value: 'symlink',
+      },
+      {
+        name: `Copy ${chalk.dim('(independent copy, manual updates)')}`,
+        value: 'copy',
+      },
+    ],
+  });
+}
+
+export async function promptConfirm(message) {
+  return confirm({ message, default: true });
+}
+
+export async function promptRemoveSelection(installed) {
+  const choices = installed.map(skill => ({
+    name: `${chalk.bold(skill.name)} ${chalk.dim(`(${skill.platformName}, ${skill.scope}, ${skill.mode})`)}`,
+    value: skill,
+    description: skill.path,
+  }));
+
+  return checkbox({
+    message: 'Select skills to remove:',
+    choices,
+    required: true,
+    instructions: chalk.dim('  (space to select, enter to confirm)'),
+  });
+}
+
+function truncate(str, max) {
+  if (!str) return '';
+  return str.length > max ? str.slice(0, max - 1) + '\u2026' : str;
+}

package/package.json

@@ -0,0 +1,38 @@
+{
+  "name": "mymskills",
+  "version": "1.0.0",
+  "description": "Interactive installer for mymediset AI skills — install domain expertise into Claude Code, Cursor, and other AI coding assistants",
+  "type": "module",
+  "bin": {
+    "mymskills": "./bin/mymskills.js"
+  },
+  "files": [
+    "bin/",
+    "lib/"
+  ],
+  "engines": {
+    "node": ">=18"
+  },
+  "keywords": [
+    "mymediset",
+    "ai-skills",
+    "claude-code",
+    "cursor",
+    "sap",
+    "medical-equipment"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/BITASIA/mym-sap-skill"
+  },
+  "license": "MIT",
+  "dependencies": {
+    "@inquirer/prompts": "^7.0.0",
+    "boxen": "^8.0.0",
+    "chalk": "^5.3.0",
+    "commander": "^12.0.0",
+    "figlet": "^1.8.0",
+    "gradient-string": "^3.0.0",
+    "ora": "^8.0.0"
+  }
+}