@adonis0123/react-best-practices 1.0.2 → 1.0.3

package/.claude-skill.json

@@ -1,7 +1,8 @@
 {
   "name": "react-best-practices",
-  "version": "1.0.0",
+  "version": "1.0.1",
   "package": "@adonis0123/react-best-practices",
+  "remoteSource": "vercel-labs/agent-skills/skills/react-best-practices",
   "files": {
     "AGENTS.md": "AGENTS.md",
     "README.md": "README.md",
@@ -14,6 +15,34 @@
         "global": ".claude/skills",
         "project": ".claude/skills"
       }
+    },
+    "cursor": {
+      "enabled": true,
+      "paths": {
+        "global": ".cursor/skills",
+        "project": ".cursor/skills"
+      }
+    },
+    "windsurf": {
+      "enabled": false,
+      "paths": {
+        "global": ".windsurf/skills",
+        "project": ".windsurf/skills"
+      }
+    },
+    "aider": {
+      "enabled": false,
+      "paths": {
+        "global": ".aider/skills",
+        "project": ".aider/skills"
+      }
+    },
+    "custom": {
+      "enabled": false,
+      "paths": {
+        "global": ".ai-skills",
+        "project": ".ai-skills"
+      }
     }
   }
 }

package/install-skill.js

@@ -1,207 +1,315 @@
 #!/usr/bin/env node
-
-const fs = require('fs');
-const path = require('path');
-const os = require('os');
-
-const { getEnabledTargets,extractSkillName, detectInstallLocation } = require('./utils');
-
-function installToTarget(target, config) {
-  console.log(`\n📦 Installing to ${target.name}...`);
-
-  // Check if this is a global installation
-  const isGlobal = process.env.npm_config_global === 'true';
-
-  // Determine installation location
-  const location = detectInstallLocation(target.paths, isGlobal);
-
-  // Extract skill name from package name (remove scope prefix)
-  const skillName = extractSkillName(config.name);
-
-  const targetDir = path.join(location.base, skillName);
-
-  // Alternative path format with full package name (including scope)
-  const altTargetDir = path.join(location.base, config.name);
-
-  console.log(`  Type: ${location.type}${isGlobal ? ' (global)' : ' (project)'}`);
-  console.log(`  Directory: ${targetDir}`);
-
-  // Clean up alternative path format
-  if (fs.existsSync(altTargetDir) && altTargetDir !== targetDir) {
-    console.log(`  🧹 Cleaning up alternative path format...`);
-    fs.rmSync(altTargetDir, { recursive: true, force: true });
-    console.log(`  ✓ Removed directory: ${config.name}`);
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
   }
-
-  // Create target directory
-  if (!fs.existsSync(targetDir)) {
-    fs.mkdirSync(targetDir, { recursive: true });
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// shared/src/install-skill.ts
+var import_fs2 = __toESM(require("fs"));
+var import_path2 = __toESM(require("path"));
+var import_os2 = __toESM(require("os"));
+var import_child_process = require("child_process");
+
+// shared/src/utils.ts
+var import_fs = __toESM(require("fs"));
+var import_path = __toESM(require("path"));
+var import_os = __toESM(require("os"));
+var CWD = process.env.INIT_CWD || process.cwd();
+var DEFAULT_TARGET = {
+  name: "claude-code",
+  paths: {
+    global: ".claude/skills",
+    project: ".claude/skills"
   }
-
-  // Copy SKILL.md (required)
-  const skillMdSource = path.join(__dirname, 'SKILL.md');
-  if (!fs.existsSync(skillMdSource)) {
-    throw new Error('SKILL.md is required but not found');
-  }
-  fs.copyFileSync(skillMdSource, path.join(targetDir, 'SKILL.md'));
-  console.log('  ✓ Copied SKILL.md');
-
-  // Copy other files
-  if (config.files) {
-    Object.entries(config.files).forEach(([source, dest]) => {
-      const sourcePath = path.join(__dirname, source);
-      if (!fs.existsSync(sourcePath)) {
-        console.warn(`  ⚠ Warning: ${source} not found, skipping`);
-        return;
-      }
-
-      const destPath = path.join(targetDir, dest);
-
-      if (fs.statSync(sourcePath).isDirectory()) {
-        copyDir(sourcePath, destPath);
-        console.log(`  ✓ Copied directory: ${source}`);
-      } else {
-        // Ensure target directory exists
-        const destDir = path.dirname(destPath);
-        if (!fs.existsSync(destDir)) {
-          fs.mkdirSync(destDir, { recursive: true });
-        }
-        fs.copyFileSync(sourcePath, destPath);
-        console.log(`  ✓ Copied file: ${source}`);
-      }
-    });
-  }
-
-  // Update manifest
-  updateManifest(location.base, config, target.name);
-
-  // Run postinstall hooks
-  if (config.hooks && config.hooks.postinstall) {
-    console.log('  🔧 Running postinstall hook...');
-    const { execSync } = require('child_process');
-    try {
-      execSync(config.hooks.postinstall, {
-        cwd: targetDir,
-        stdio: 'pipe'
-      });
-      console.log('  ✓ Postinstall hook completed');
-    } catch (error) {
-      console.warn(`  ⚠ Warning: postinstall hook failed`);
-    }
+};
+function getEnabledTargets(config) {
+  if (!config.targets) {
+    return [DEFAULT_TARGET];
   }
-
-  console.log(`  ✅ Installed to ${target.name}`);
-  return targetDir;
+  return Object.entries(config.targets).filter(([_, target]) => target.enabled).map(([name, target]) => ({
+    name,
+    paths: target.paths
+  }));
 }
-
-function installSkill() {
-  console.log('🚀 Installing AI Coding Skill...\n');
-
-  // Read configuration
-  const configPath = path.join(__dirname, '.claude-skill.json');
-  if (!fs.existsSync(configPath)) {
-    throw new Error('.claude-skill.json not found');
+function extractSkillName(packageName) {
+  if (packageName.startsWith("@")) {
+    return packageName.split("/")[1] || packageName;
   }
-  const config = JSON.parse(fs.readFileSync(configPath, 'utf8'));
-
-  // Get enabled targets
-  const enabledTargets = getEnabledTargets(config);
-
-  if (enabledTargets.length === 0) {
-    console.warn('⚠ No targets enabled in configuration');
-    console.warn('Please enable at least one target in .claude-skill.json');
-    return;
+  return packageName;
+}
+function detectInstallLocation(targetPaths, isGlobal) {
+  if (isGlobal) {
+    return {
+      type: "personal",
+      base: import_path.default.join(import_os.default.homedir(), targetPaths.global)
+    };
   }
-
-  console.log(`Installing skill "${config.name}" to ${enabledTargets.length} target(s):`);
-  enabledTargets.forEach(target => {
-    console.log(`  • ${target.name}`);
-  });
-
-  // Install to all enabled targets
-  const installedPaths = [];
-  for (const target of enabledTargets) {
-    try {
-      const installPath = installToTarget(target, config);
-      installedPaths.push({ target: target.name, path: installPath });
-    } catch (error) {
-      console.error(`\n❌ Failed to install to ${target.name}:`, error.message);
+  let projectRoot = CWD;
+  while (projectRoot !== import_path.default.dirname(projectRoot)) {
+    const hasPackageJson = import_fs.default.existsSync(import_path.default.join(projectRoot, "package.json"));
+    const hasGit = import_fs.default.existsSync(import_path.default.join(projectRoot, ".git"));
+    const isInNodeModules = projectRoot.includes("/node_modules/") || import_path.default.basename(projectRoot) === "node_modules";
+    if ((hasPackageJson || hasGit) && !isInNodeModules) {
+      break;
     }
+    projectRoot = import_path.default.dirname(projectRoot);
   }
-
-  // Summary
-  console.log('\n' + '='.repeat(60));
-  console.log('✅ Installation Complete!');
-  console.log('='.repeat(60));
-
-  if (installedPaths.length > 0) {
-    console.log('\nInstalled to:');
-    installedPaths.forEach(({ target, path: installPath }) => {
-      console.log(`  • ${target}: ${installPath}`);
-    });
-
-    console.log('\n📖 Next Steps:');
-    console.log('  1. Restart your AI coding tool(s)');
-    console.log('  2. Ask: "What skills are available?"');
-    console.log('  3. Start using your skill!');
+  const finalIsInNodeModules = projectRoot.includes("/node_modules/") || import_path.default.basename(projectRoot) === "node_modules";
+  if (finalIsInNodeModules) {
+    console.warn("\u26A0 Warning: Could not find project root directory, using current directory");
+    projectRoot = CWD;
   }
+  return {
+    type: "project",
+    base: import_path.default.join(projectRoot, targetPaths.project)
+  };
+}
+function isGlobalInstall() {
+  return process.env.npm_config_global === "true";
 }
-
 function copyDir(src, dest) {
-  fs.mkdirSync(dest, { recursive: true });
-  const entries = fs.readdirSync(src, { withFileTypes: true });
-
-  for (let entry of entries) {
-    const srcPath = path.join(src, entry.name);
-    const destPath = path.join(dest, entry.name);
-
+  import_fs.default.mkdirSync(dest, { recursive: true });
+  const entries = import_fs.default.readdirSync(src, { withFileTypes: true });
+  for (const entry of entries) {
+    const srcPath = import_path.default.join(src, entry.name);
+    const destPath = import_path.default.join(dest, entry.name);
     if (entry.isDirectory()) {
       copyDir(srcPath, destPath);
     } else {
-      fs.copyFileSync(srcPath, destPath);
+      import_fs.default.copyFileSync(srcPath, destPath);
     }
   }
 }
+function ensureDir(dir) {
+  if (!import_fs.default.existsSync(dir)) {
+    import_fs.default.mkdirSync(dir, { recursive: true });
+  }
+}
+function removeDir(dir) {
+  if (import_fs.default.existsSync(dir)) {
+    import_fs.default.rmSync(dir, { recursive: true, force: true });
+  }
+}
+function readSkillConfig(dir) {
+  const configPath = import_path.default.join(dir, ".claude-skill.json");
+  if (!import_fs.default.existsSync(configPath)) {
+    throw new Error(".claude-skill.json not found");
+  }
+  return JSON.parse(import_fs.default.readFileSync(configPath, "utf-8"));
+}
 
-function updateManifest(skillsDir, config, targetName) {
-  const manifestPath = path.join(skillsDir, '.skills-manifest.json');
+// shared/src/install-skill.ts
+function fetchFromRemote(tempDir, remoteSource) {
+  try {
+    console.log(`  \u{1F310} Fetching latest from ${remoteSource}...`);
+    (0, import_child_process.execSync)(`npx degit ${remoteSource} "${tempDir}" --force`, {
+      stdio: "pipe",
+      timeout: 6e4
+    });
+    if (import_fs2.default.existsSync(import_path2.default.join(tempDir, "SKILL.md"))) {
+      console.log("  \u2713 Fetched latest version from remote");
+      return true;
+    }
+    console.warn("  \u26A0 Remote fetch succeeded but SKILL.md not found");
+    return false;
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    console.warn(`  \u26A0 Could not fetch from remote: ${message}`);
+    console.log("  \u2139 Using bundled version as fallback");
+    return false;
+  }
+}
+function getSourceDir(config, packageDir) {
+  if (!config.remoteSource) {
+    return {
+      sourceDir: packageDir,
+      cleanup: () => {
+      },
+      isRemote: false
+    };
+  }
+  const tempDir = import_path2.default.join(import_os2.default.tmpdir(), `skill-fetch-${Date.now()}`);
+  const remoteSuccess = fetchFromRemote(tempDir, config.remoteSource);
+  if (remoteSuccess) {
+    return {
+      sourceDir: tempDir,
+      cleanup: () => {
+        try {
+          import_fs2.default.rmSync(tempDir, { recursive: true, force: true });
+        } catch {
+        }
+      },
+      isRemote: true
+    };
+  }
+  try {
+    import_fs2.default.rmSync(tempDir, { recursive: true, force: true });
+  } catch {
+  }
+  return {
+    sourceDir: packageDir,
+    cleanup: () => {
+    },
+    isRemote: false
+  };
+}
+function updateManifest(skillsDir, config, targetName, isRemote) {
+  const manifestPath = import_path2.default.join(skillsDir, ".skills-manifest.json");
   let manifest = { skills: {} };
-
-  if (fs.existsSync(manifestPath)) {
+  if (import_fs2.default.existsSync(manifestPath)) {
     try {
-      manifest = JSON.parse(fs.readFileSync(manifestPath, 'utf8'));
-    } catch (error) {
-      console.warn('  Warning: Could not parse existing manifest, creating new one');
+      manifest = JSON.parse(import_fs2.default.readFileSync(manifestPath, "utf-8"));
+    } catch {
+      console.warn("  Warning: Could not parse existing manifest, creating new one");
       manifest = { skills: {} };
     }
   }
-
-  // Extract skill name from package name (remove scope prefix)
-  const skillName = config.name.startsWith('@') ?
-    config.name.split('/')[1] || config.name :
-    config.name;
-
+  const skillName = extractSkillName(config.name);
   manifest.skills[config.name] = {
     version: config.version,
-    installedAt: new Date().toISOString(),
+    installedAt: (/* @__PURE__ */ new Date()).toISOString(),
     package: config.package || config.name,
-    path: path.join(skillsDir, skillName),
-    target: targetName
+    path: import_path2.default.join(skillsDir, skillName),
+    target: targetName,
+    ...config.remoteSource && { source: config.remoteSource }
   };
-
-  fs.writeFileSync(manifestPath, JSON.stringify(manifest, null, 2));
+  import_fs2.default.writeFileSync(manifestPath, JSON.stringify(manifest, null, 2));
+}
+function installToTarget(target, config, sourceDir, isRemote) {
+  var _a;
+  console.log(`
+\u{1F4E6} Installing to ${target.name}...`);
+  const isGlobal = isGlobalInstall();
+  const location = detectInstallLocation(target.paths, isGlobal);
+  const skillName = extractSkillName(config.name);
+  const targetDir = import_path2.default.join(location.base, skillName);
+  const altTargetDir = import_path2.default.join(location.base, config.name);
+  console.log(`  Type: ${location.type}${isGlobal ? " (global)" : " (project)"}`);
+  console.log(`  Directory: ${targetDir}`);
+  if (import_fs2.default.existsSync(altTargetDir) && altTargetDir !== targetDir) {
+    console.log("  \u{1F9F9} Cleaning up alternative path format...");
+    removeDir(altTargetDir);
+    console.log(`  \u2713 Removed directory: ${config.name}`);
+  }
+  ensureDir(targetDir);
+  const skillMdSource = import_path2.default.join(sourceDir, "SKILL.md");
+  if (!import_fs2.default.existsSync(skillMdSource)) {
+    throw new Error("SKILL.md is required but not found");
+  }
+  import_fs2.default.copyFileSync(skillMdSource, import_path2.default.join(targetDir, "SKILL.md"));
+  console.log("  \u2713 Copied SKILL.md");
+  const filesToCopy = config.files || {};
+  for (const [source, dest] of Object.entries(filesToCopy)) {
+    const sourcePath = import_path2.default.join(sourceDir, source);
+    if (!import_fs2.default.existsSync(sourcePath)) {
+      console.warn(`  \u26A0 Warning: ${source} not found, skipping`);
+      continue;
+    }
+    const destPath = import_path2.default.join(targetDir, dest);
+    if (import_fs2.default.statSync(sourcePath).isDirectory()) {
+      copyDir(sourcePath, destPath);
+      console.log(`  \u2713 Copied directory: ${source}`);
+    } else {
+      const destDir = import_path2.default.dirname(destPath);
+      ensureDir(destDir);
+      import_fs2.default.copyFileSync(sourcePath, destPath);
+      console.log(`  \u2713 Copied file: ${source}`);
+    }
+  }
+  updateManifest(location.base, config, target.name, isRemote);
+  if ((_a = config.hooks) == null ? void 0 : _a.postinstall) {
+    console.log("  \u{1F527} Running postinstall hook...");
+    try {
+      (0, import_child_process.execSync)(config.hooks.postinstall, {
+        cwd: targetDir,
+        stdio: "pipe"
+      });
+      console.log("  \u2713 Postinstall hook completed");
+    } catch {
+      console.warn("  \u26A0 Warning: postinstall hook failed");
+    }
+  }
+  console.log(`  \u2705 Installed to ${target.name}`);
+  return targetDir;
+}
+function installSkill() {
+  console.log("\u{1F680} Installing AI Coding Skill...\n");
+  const packageDir = __dirname;
+  const config = readSkillConfig(packageDir);
+  const enabledTargets = getEnabledTargets(config);
+  if (enabledTargets.length === 0) {
+    console.warn("\u26A0 No targets enabled in configuration");
+    console.warn("Please enable at least one target in .claude-skill.json");
+    return;
+  }
+  console.log(`Installing skill "${config.name}" to ${enabledTargets.length} target(s):`);
+  enabledTargets.forEach((target) => {
+    console.log(`  \u2022 ${target.name}`);
+  });
+  const { sourceDir, cleanup, isRemote } = getSourceDir(config, packageDir);
+  if (isRemote) {
+    console.log(`
+\u{1F4E1} Source: Remote (${config.remoteSource})`);
+  } else {
+    console.log("\n\u{1F4E6} Source: Bundled (local)");
+  }
+  try {
+    const installedPaths = [];
+    for (const target of enabledTargets) {
+      try {
+        const installPath = installToTarget(target, config, sourceDir, isRemote);
+        installedPaths.push({ target: target.name, path: installPath });
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        console.error(`
+\u274C Failed to install to ${target.name}:`, message);
+      }
+    }
+    console.log("\n" + "=".repeat(60));
+    console.log("\u2705 Installation Complete!");
+    console.log("=".repeat(60));
+    if (installedPaths.length > 0) {
+      console.log("\nInstalled to:");
+      installedPaths.forEach(({ target, path: installPath }) => {
+        console.log(`  \u2022 ${target}: ${installPath}`);
+      });
+      console.log("\n\u{1F4D6} Next Steps:");
+      console.log("  1. Restart your AI coding tool(s)");
+      console.log('  2. Ask: "What skills are available?"');
+      console.log("  3. Start using your skill!");
+    }
+  } finally {
+    cleanup();
+  }
 }
-
-// Execute installation
 try {
   installSkill();
 } catch (error) {
-  console.error('\n❌ Failed to install skill:', error.message);
-  console.error('\nTroubleshooting:');
-  console.error('- Ensure .claude-skill.json exists and is valid JSON');
-  console.error('- Ensure SKILL.md exists');
-  console.error('- Check file permissions for target directories');
-  console.error('- Verify at least one target is enabled in .claude-skill.json');
-  console.error('- Try running with sudo for global installation (if needed)');
+  const message = error instanceof Error ? error.message : String(error);
+  console.error("\n\u274C Failed to install skill:", message);
+  console.error("\nTroubleshooting:");
+  console.error("- Ensure .claude-skill.json exists and is valid JSON");
+  console.error("- Ensure SKILL.md exists");
+  console.error("- Check file permissions for target directories");
+  console.error("- Verify at least one target is enabled in .claude-skill.json");
+  console.error("- Try running with sudo for global installation (if needed)");
   process.exit(1);
 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@adonis0123/react-best-practices",
-  "version": "1.0.2",
-  "description": "Claude Code Skill - React 和 Next.js 性能优化最佳实践指南，来自 Vercel Engineering",
+  "version": "1.0.3",
+  "description": "Claude Code Skill - React 和 Next.js 性能优化最佳实践指南，来自 Vercel Engineering。安装时自动从上游仓库拉取最新版本。",
   "files": [
     "SKILL.md",
     "AGENTS.md",

package/uninstall-skill.js

@@ -1,87 +1,162 @@
 #!/usr/bin/env node
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// shared/src/uninstall-skill.ts
+var import_fs2 = __toESM(require("fs"));
+var import_path2 = __toESM(require("path"));
+
+// shared/src/utils.ts
+var import_fs = __toESM(require("fs"));
+var import_path = __toESM(require("path"));
+var import_os = __toESM(require("os"));
+var CWD = process.env.INIT_CWD || process.cwd();
+var DEFAULT_TARGET = {
+  name: "claude-code",
+  paths: {
+    global: ".claude/skills",
+    project: ".claude/skills"
+  }
+};
+function getEnabledTargets(config) {
+  if (!config.targets) {
+    return [DEFAULT_TARGET];
+  }
+  return Object.entries(config.targets).filter(([_, target]) => target.enabled).map(([name, target]) => ({
+    name,
+    paths: target.paths
+  }));
+}
+function extractSkillName(packageName) {
+  if (packageName.startsWith("@")) {
+    return packageName.split("/")[1] || packageName;
+  }
+  return packageName;
+}
+function detectInstallLocation(targetPaths, isGlobal) {
+  if (isGlobal) {
+    return {
+      type: "personal",
+      base: import_path.default.join(import_os.default.homedir(), targetPaths.global)
+    };
+  }
+  let projectRoot = CWD;
+  while (projectRoot !== import_path.default.dirname(projectRoot)) {
+    const hasPackageJson = import_fs.default.existsSync(import_path.default.join(projectRoot, "package.json"));
+    const hasGit = import_fs.default.existsSync(import_path.default.join(projectRoot, ".git"));
+    const isInNodeModules = projectRoot.includes("/node_modules/") || import_path.default.basename(projectRoot) === "node_modules";
+    if ((hasPackageJson || hasGit) && !isInNodeModules) {
+      break;
+    }
+    projectRoot = import_path.default.dirname(projectRoot);
+  }
+  const finalIsInNodeModules = projectRoot.includes("/node_modules/") || import_path.default.basename(projectRoot) === "node_modules";
+  if (finalIsInNodeModules) {
+    console.warn("\u26A0 Warning: Could not find project root directory, using current directory");
+    projectRoot = CWD;
+  }
+  return {
+    type: "project",
+    base: import_path.default.join(projectRoot, targetPaths.project)
+  };
+}
+function isGlobalInstall() {
+  return process.env.npm_config_global === "true";
+}
+function removeDir(dir) {
+  if (import_fs.default.existsSync(dir)) {
+    import_fs.default.rmSync(dir, { recursive: true, force: true });
+  }
+}
+function readSkillConfig(dir) {
+  const configPath = import_path.default.join(dir, ".claude-skill.json");
+  if (!import_fs.default.existsSync(configPath)) {
+    throw new Error(".claude-skill.json not found");
+  }
+  return JSON.parse(import_fs.default.readFileSync(configPath, "utf-8"));
+}
 
-const fs = require('fs');
-const path = require('path');
-const os = require('os');
-
-const { getEnabledTargets, extractSkillName, detectInstallLocation } = require('./utils');
-
+// shared/src/uninstall-skill.ts
+function updateManifest(skillsDir, config) {
+  const manifestPath = import_path2.default.join(skillsDir, ".skills-manifest.json");
+  if (!import_fs2.default.existsSync(manifestPath)) {
+    return;
+  }
+  try {
+    const manifest = JSON.parse(import_fs2.default.readFileSync(manifestPath, "utf-8"));
+    if (manifest.skills && manifest.skills[config.name]) {
+      delete manifest.skills[config.name];
+      import_fs2.default.writeFileSync(manifestPath, JSON.stringify(manifest, null, 2));
+      console.log("  \u2713 Updated manifest");
+    }
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    console.warn("  Warning: Could not update manifest:", message);
+  }
+}
 function uninstallFromTarget(target, config) {
-  console.log(`\n🗑️  Uninstalling from ${target.name}...`);
-
-  const isGlobal = process.env.npm_config_global === 'true';
+  console.log(`
+\u{1F5D1}\uFE0F  Uninstalling from ${target.name}...`);
+  const isGlobal = isGlobalInstall();
   const location = detectInstallLocation(target.paths, isGlobal);
-
-  // Extract skill name from package name (remove scope prefix)
   const skillName = extractSkillName(config.name);
-
-  // Path format using skill name
-  const skillNameTargetDir = path.join(location.base, skillName);
-
-  // Path format with full package name (including scope)
-  const fullPackageNameTargetDir = path.join(location.base, config.name);
-
+  const skillNameTargetDir = import_path2.default.join(location.base, skillName);
+  const fullPackageNameTargetDir = import_path2.default.join(location.base, config.name);
   let removed = false;
-
-  // Check and remove path using skill name
-  if (fs.existsSync(skillNameTargetDir)) {
-    fs.rmSync(skillNameTargetDir, { recursive: true, force: true });
-    console.log(`  ✓ Removed skill directory: ${skillName}`);
+  if (import_fs2.default.existsSync(skillNameTargetDir)) {
+    removeDir(skillNameTargetDir);
+    console.log(`  \u2713 Removed skill directory: ${skillName}`);
     removed = true;
   }
-
-  // Check and remove path with full package name (for compatibility)
-  if (fs.existsSync(fullPackageNameTargetDir) && fullPackageNameTargetDir !== skillNameTargetDir) {
-    fs.rmSync(fullPackageNameTargetDir, { recursive: true, force: true });
-    console.log(`  ✓ Removed skill directory: ${config.name}`);
+  if (import_fs2.default.existsSync(fullPackageNameTargetDir) && fullPackageNameTargetDir !== skillNameTargetDir) {
+    removeDir(fullPackageNameTargetDir);
+    console.log(`  \u2713 Removed skill directory: ${config.name}`);
     removed = true;
   }
-
-  // Update manifest
-  const manifestPath = path.join(location.base, '.skills-manifest.json');
-  if (fs.existsSync(manifestPath)) {
-    try {
-      const manifest = JSON.parse(fs.readFileSync(manifestPath, 'utf8'));
-      if (manifest.skills && manifest.skills[config.name]) {
-        delete manifest.skills[config.name];
-        fs.writeFileSync(manifestPath, JSON.stringify(manifest, null, 2));
-        console.log(`  ✓ Updated manifest`);
-      }
-    } catch (error) {
-      console.warn('  Warning: Could not update manifest:', error.message);
-    }
-  }
-
+  updateManifest(location.base, config);
   if (removed) {
-    console.log(`  ✅ Uninstalled from ${target.name}`);
+    console.log(`  \u2705 Uninstalled from ${target.name}`);
     return true;
   } else {
-    console.log(`  ℹ️  Skill was not installed in ${target.name}`);
+    console.log(`  \u2139\uFE0F  Skill was not installed in ${target.name}`);
     return false;
   }
 }
-
 function uninstallSkill() {
-  console.log('🗑️  Uninstalling AI Coding Skill...\n');
-
-  // Read configuration
-  const configPath = path.join(__dirname, '.claude-skill.json');
-  if (!fs.existsSync(configPath)) {
-    console.warn('Warning: .claude-skill.json not found, skipping cleanup');
+  console.log("\u{1F5D1}\uFE0F  Uninstalling AI Coding Skill...\n");
+  const packageDir = __dirname;
+  let config;
+  try {
+    config = readSkillConfig(packageDir);
+  } catch {
+    console.warn("Warning: .claude-skill.json not found, skipping cleanup");
     return;
   }
-
-  const config = JSON.parse(fs.readFileSync(configPath, 'utf8'));
-
-  // Get enabled targets
   const enabledTargets = getEnabledTargets(config);
-
   console.log(`Uninstalling skill "${config.name}" from ${enabledTargets.length} target(s):`);
-  enabledTargets.forEach(target => {
-    console.log(`  • ${target.name}`);
+  enabledTargets.forEach((target) => {
+    console.log(`  \u2022 ${target.name}`);
   });
-
-  // Uninstall from all enabled targets
   const uninstalledFrom = [];
   for (const target of enabledTargets) {
     try {
@@ -90,29 +165,27 @@ function uninstallSkill() {
         uninstalledFrom.push(target.name);
       }
     } catch (error) {
-      console.error(`\n❌ Failed to uninstall from ${target.name}:`, error.message);
+      const message = error instanceof Error ? error.message : String(error);
+      console.error(`
+\u274C Failed to uninstall from ${target.name}:`, message);
     }
   }
-
-  // Summary
-  console.log('\n' + '='.repeat(60));
+  console.log("\n" + "=".repeat(60));
   if (uninstalledFrom.length > 0) {
-    console.log('✅ Uninstallation Complete!');
-    console.log('='.repeat(60));
-    console.log('\nUninstalled from:');
-    uninstalledFrom.forEach(target => {
-      console.log(`  • ${target}`);
+    console.log("\u2705 Uninstallation Complete!");
+    console.log("=".repeat(60));
+    console.log("\nUninstalled from:");
+    uninstalledFrom.forEach((target) => {
+      console.log(`  \u2022 ${target}`);
     });
   } else {
-    console.log('ℹ️  Skill was not installed');
-    console.log('='.repeat(60));
+    console.log("\u2139\uFE0F  Skill was not installed");
+    console.log("=".repeat(60));
   }
 }
-
-// Execute uninstall
 try {
   uninstallSkill();
 } catch (error) {
-  console.error('\n⚠️  Warning during uninstall:', error.message);
-  // Don't exit with error code as uninstall should be best-effort
+  const message = error instanceof Error ? error.message : String(error);
+  console.error("\n\u26A0\uFE0F  Warning during uninstall:", message);
 }

package/utils.js

@@ -1,94 +0,0 @@
-const fs = require('fs');
-const path = require('path');
-const os = require('os');
-
-const CWD = process.env.INIT_CWD || process.cwd();
-
-/**
- * Get enabled target configurations
- */
-function getEnabledTargets(config) {
-  // If no targets configuration, use default Claude Code configuration
-  if (!config.targets) {
-    return [{
-      name: 'claude-code',
-      paths: {
-        global: '.claude/skills',
-        project: '.claude/skills'
-      }
-    }];
-  }
-
-  // Return all enabled targets
-  return Object.entries(config.targets)
-    .filter(([_, target]) => target.enabled)
-    .map(([name, target]) => ({
-      name,
-      paths: target.paths
-    }));
-}
-
-/**
- * Extract skill name from package name (remove scope prefix)
- */
-function extractSkillName(packageName) {
-  return packageName.startsWith('@') ?
-    packageName.split('/')[1] || packageName :
-    packageName;
-}
-
-/**
- * Detect installation location
- */
-function detectInstallLocation(targetPaths, isGlobal) {
-  if (isGlobal) {
-    // Global installation: install to user home directory
-    return {
-      type: 'personal',
-      base: path.join(os.homedir(), targetPaths.global)
-    };
-  } else {
-    // Project-level installation: find the actual project root directory
-    let projectRoot = CWD;
-
-    // Search upward, skip node_modules directories, find the actual project root
-    while (projectRoot !== path.dirname(projectRoot)) {
-      // Check if this is a project root directory (contains package.json or .git)
-      const hasPackageJson = fs.existsSync(path.join(projectRoot, 'package.json'));
-      const hasGit = fs.existsSync(path.join(projectRoot, '.git'));
-
-      // Check if current directory is in node_modules
-      const isInNodeModules = projectRoot.includes('/node_modules/') ||
-                             path.basename(projectRoot) === 'node_modules';
-
-      if ((hasPackageJson || hasGit) && !isInNodeModules) {
-        // Found the actual project root directory
-        break;
-      }
-
-      // Continue searching upward
-      projectRoot = path.dirname(projectRoot);
-    }
-
-    // Verify the final path is reasonable
-    const finalIsInNodeModules = projectRoot.includes('/node_modules/') ||
-                                path.basename(projectRoot) === 'node_modules';
-
-    if (finalIsInNodeModules) {
-      // If suitable project root not found, use current working directory (with warning)
-      console.warn('⚠ Warning: Could not find project root directory, using current directory');
-      projectRoot = CWD;
-    }
-
-    return {
-      type: 'project',
-      base: path.join(projectRoot, targetPaths.project)
-    };
-  }
-}
-
-module.exports = {
-  getEnabledTargets,
-  extractSkillName,
-  detectInstallLocation
-};