kungeskill 0.1.0

package/README.md

@@ -0,0 +1,68 @@
+# kunge-skills
+
+OpenSpec-based development workflow skills for Claude Code.
+
+This marketplace provides reusable skills that enable a spec-driven approach to software development: explore ideas, propose changes, implement tasks, and archive results -- plus a knowledge base for code analysis and business logic documentation.
+
+## Installation
+
+### Add the marketplace
+
+```
+/plugin marketplace add kunge2013/skills
+```
+
+### Install individual plugins
+
+```
+# Spec-driven change lifecycle (explore, propose, apply, archive)
+/plugin install openspec-workflow@kunge-skills
+
+# Code analysis and business logic knowledge base
+/plugin install openspec-trace@kunge-skills
+```
+
+### Update to latest
+
+```
+/plugin marketplace update kunge-skills
+```
+
+## Available Plugins
+
+### openspec-workflow
+
+Spec-driven change lifecycle for Claude Code. Enables you to:
+
+- **Explore** ideas and requirements before writing code
+- **Propose** changes with structured proposal, design, and task artifacts
+- **Apply** tasks through sequential, verifiable implementation
+- **Archive** completed changes with spec synchronization
+
+| Skill | Description |
+|-------|-------------|
+| `openspec-explore` | Enter explore mode -- a thinking partner for exploring ideas, investigating problems, and clarifying requirements |
+| `openspec-propose` | Propose a new change with all artifacts (proposal, design, tasks) generated in one step |
+| `openspec-apply-change` | Implement tasks from an OpenSpec change, working through them sequentially with progress tracking |
+| `openspec-archive-change` | Archive a completed change, with optional delta spec sync to main specs |
+
+### openspec-trace
+
+Code analysis and business logic knowledge base. Enables you to:
+
+- **Archive** code changes from OpenSpec changes into a versioned knowledge base
+- **Search** archived business logic documents by keyword, domain, or exact module
+
+| Skill | Description |
+|-------|-------------|
+| `opst-code-anysic` | Analyze archived OpenSpec change code, extract business logic, and archive into a versioned knowledge base with five-section design documents |
+| `opst-business-search` | Search the archived business logic knowledge base by keyword, browse by domain, or view exact modules |
+
+## Tech Stack
+
+- OpenSpec (spec-driven development workflow)
+- Claude Code skills framework
+
+## License
+
+MIT

package/package.json

@@ -0,0 +1,31 @@
+{
+  "name": "kungeskill",
+  "version": "0.1.0",
+  "description": "Manage Claude Code skills via symlinks — install, remove, update skills from a marketplace cache",
+  "main": "src/cli.js",
+  "bin": {
+    "kungeskill": "src/cli.js"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "files": [
+    "src/**/*.js"
+  ],
+  "scripts": {
+    "start": "node src/cli.js",
+    "prepublishOnly": "node src/cli.js --version",
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "keywords": ["claude-code", "skills", "marketplace", "symlink", "skill-manager"],
+  "author": "kungeskills",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/kunge2013/skills"
+  },
+  "bugs": {
+    "url": "https://github.com/kunge2013/skills/issues"
+  },
+  "homepage": "https://github.com/kunge2013/skills#readme"
+}

package/src/cli.js

@@ -0,0 +1,129 @@
+#!/usr/bin/env node
+'use strict';
+
+// [AGC:START] tool=Cc author=fangkun
+const { cmdInit } = require('./commands/init');
+const { cmdList } = require('./commands/list');
+const { cmdAdd } = require('./commands/add');
+const { cmdRemove } = require('./commands/remove');
+const { cmdView } = require('./commands/view');
+const { cmdUpdate } = require('./commands/update');
+const { cmdDoctor } = require('./commands/doctor');
+const logger = require('./utils/logger');
+
+const VERSION = '0.1.0';
+const USAGE = `
+Usage: kungeskill <command> [options]
+
+Commands:
+  init               Initialize marketplace cache
+  list               List available skills in the marketplace
+    --installed        Show only installed skills in this project
+  add <skill>        Install a skill via symlink
+    --force            Reinstall even if already installed
+  remove <skill>     Remove a skill symlink from this project
+  view               Show installed skills with health status
+  update             Update marketplace cache via git pull
+  doctor             Check symlink health and cache status
+
+Options:
+  --help, -h         Show help
+  --version, -v      Show version
+`;
+
+function parseArgs(argv) {
+  const args = argv.slice(2); // skip node and script path
+  const result = { command: null, positional: [], flags: {} };
+
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    if (arg === '--help' || arg === '-h') {
+      result.flags.help = true;
+    } else if (arg === '--version' || arg === '-v') {
+      result.flags.version = true;
+    } else if (arg === '--installed') {
+      result.flags.installed = true;
+    } else if (arg === '--force') {
+      result.flags.force = true;
+    } else if (!result.command) {
+      result.command = arg;
+    } else {
+      result.positional.push(arg);
+    }
+  }
+  return result;
+}
+
+async function main() {
+  const parsed = parseArgs(process.argv);
+
+  if (parsed.flags.help) {
+    console.log(USAGE.trim());
+    return;
+  }
+
+  if (parsed.flags.version) {
+    console.log(`kungeskill v${VERSION}`);
+    return;
+  }
+
+  if (!parsed.command) {
+    console.log(USAGE.trim());
+    process.exit(0);
+  }
+
+  try {
+    switch (parsed.command) {
+      case 'init':
+        await cmdInit();
+        break;
+
+      case 'list':
+        cmdList({ installed: parsed.flags.installed });
+        break;
+
+      case 'add': {
+        const skillName = parsed.positional[0];
+        if (!skillName) {
+          logger.error('Missing skill name. Usage: kungeskill add <skill>');
+          process.exit(1);
+        }
+        await cmdAdd(skillName, { force: parsed.flags.force });
+        break;
+      }
+
+      case 'remove': {
+        const skillName = parsed.positional[0];
+        if (!skillName) {
+          logger.error('Missing skill name. Usage: kungeskill remove <skill>');
+          process.exit(1);
+        }
+        cmdRemove(skillName);
+        break;
+      }
+
+      case 'view':
+        cmdView();
+        break;
+
+      case 'update':
+        await cmdUpdate();
+        break;
+
+      case 'doctor':
+        cmdDoctor();
+        break;
+
+      default:
+        logger.error(`Unknown command: ${parsed.command}`);
+        console.log(USAGE.trim());
+        process.exit(1);
+    }
+  } catch (err) {
+    logger.error(err.message || String(err));
+    process.exit(1);
+  }
+}
+
+main();
+// [AGC:END]

package/src/commands/add.js

@@ -0,0 +1,81 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const { getMarketplaceSourceDir, isCacheValid } = require('../core/cache');
+const { parseMarketplace, findSkill } = require('../core/registry');
+const { createSkillSymlink, canCreateJunction, copyDirRecursive } = require('../core/symlink');
+const { findProjectSkillsDir } = require('./shared');
+const logger = require('../utils/logger');
+
+async function cmdAdd(skillName, opts) {
+  const force = opts.force || false;
+
+  // Ensure cache exists
+  if (!isCacheValid()) {
+    logger.info('Marketplace cache not initialized. Running init...');
+    const { cmdInit } = require('./init');
+    await cmdInit();
+  }
+
+  const cacheDir = getMarketplaceSourceDir();
+  const marketplace = parseMarketplace(cacheDir);
+
+  if (!marketplace) {
+    logger.error('Invalid marketplace manifest.');
+    process.exit(1);
+  }
+
+  // Find the skill in the marketplace
+  const skill = findSkill(marketplace, cacheDir, skillName);
+  if (!skill) {
+    logger.error(`Skill '${skillName}' not found in marketplace.`);
+    logger.info('Run "kungeskill list" to see available skills.');
+    process.exit(1);
+  }
+
+  // Verify source has SKILL.md
+  const skillMdPath = path.join(skill.sourcePath, 'SKILL.md');
+  if (!fs.existsSync(skillMdPath)) {
+    logger.error(`Skill source directory is missing SKILL.md: ${skill.sourcePath}`);
+    process.exit(1);
+  }
+
+  // Find or create project skills directory
+  const skillsDir = findProjectSkillsDir();
+  const linkPath = path.join(skillsDir, skillName);
+
+  // Check if already installed
+  if (fs.existsSync(linkPath)) {
+    if (force) {
+      logger.info(`Skill '${skillName}' already installed. Reinstalling (--force)...`);
+      fs.rmSync(linkPath, { recursive: true, force: true });
+    } else {
+      logger.warn(`Skill '${skillName}' is already installed.`);
+      logger.info('Use --force to reinstall.');
+      return;
+    }
+  }
+
+  // Try symlink first, fallback to copy on cross-drive Windows
+  try {
+    createSkillSymlink(skill.sourcePath, linkPath);
+    logger.success(`Installed ${skillName}`);
+    logger.dim(`  Link: ${linkPath}`);
+    logger.dim(`  Source: ${skill.sourcePath} (symlink)`);
+  } catch (err) {
+    // Fallback: copy directory if symlink fails (cross-drive on Windows)
+    if (err.message.includes('across drives')) {
+      logger.warn(`Cannot create symlink (cross-drive). Falling back to copy mode.`);
+      logger.warn(`  Updates will NOT auto-sync. Run "kungeskill add --force ${skillName}" after update.`);
+      copyDirRecursive(skill.sourcePath, linkPath);
+      logger.success(`Installed ${skillName} (copied)`);
+      logger.dim(`  Path: ${linkPath}`);
+    } else {
+      logger.error(`Failed to install '${skillName}': ${err.message}`);
+      process.exit(1);
+    }
+  }
+}
+
+module.exports = { cmdAdd };

package/src/commands/doctor.js

@@ -0,0 +1,115 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const { getConfig } = require('../core/config');
+const { getCacheDir, isCacheValid } = require('../core/cache');
+const { parseMarketplace, listAllSkills } = require('../core/registry');
+const { getSymlinkStatus } = require('../core/symlink');
+const { findProjectSkillsDir } = require('./shared');
+const logger = require('../utils/logger');
+
+function cmdDoctor() {
+  const config = getConfig();
+  const cacheDir = getCacheDir();
+  let issues = 0;
+  let warnings = 0;
+
+  logger.header('kungeskill doctor');
+  console.log();
+
+  // Check 1: Cache directory
+  logger.header('Cache:');
+  if (isCacheValid()) {
+    logger.status('  \u2713', `Cache directory: ${cacheDir}`);
+  } else {
+    logger.status('  \u2717', `Cache directory missing or not a git repo`);
+    issues++;
+    logger.warn('  Run "kungeskill init" to initialize.');
+  }
+  console.log();
+
+  // Check 2: Marketplace manifest
+  logger.header('Marketplace:');
+  if (isCacheValid()) {
+    const marketplace = parseMarketplace(cacheDir);
+    if (marketplace && marketplace.plugins) {
+      const pluginCount = marketplace.plugins.length;
+      const skills = listAllSkills(marketplace, cacheDir);
+      logger.status('  \u2713', `Manifest valid (${pluginCount} plugins, ${skills.length} skills)`);
+    } else {
+      logger.status('  \u2717', 'Invalid marketplace manifest');
+      issues++;
+    }
+  } else {
+    logger.status('  \u2717', 'Cannot check manifest (cache not initialized)');
+    issues++;
+  }
+
+  if (config.marketplace.lastSync) {
+    logger.status('  ', `Last synced: ${new Date(config.marketplace.lastSync).toLocaleString()}`);
+  } else {
+    logger.status('  ', 'Never synced');
+  }
+  console.log();
+
+  // Check 3: Project skills
+  logger.header('Project Skills:');
+  const skillsDir = findProjectSkillsDir();
+
+  if (!fs.existsSync(skillsDir)) {
+    logger.status('  ', 'No skills installed in this project');
+    console.log();
+    logger.header('Summary:');
+    logger.status('  ', `${issues} issues, ${warnings} warnings`);
+    return;
+  }
+
+  const entries = fs.readdirSync(skillsDir, { withFileTypes: true });
+  const skills = entries
+    .filter(e => e.isDirectory() || e.isSymbolicLink())
+    .map(e => e.name);
+
+  let okCount = 0;
+  let brokenCount = 0;
+
+  for (const name of skills) {
+    const linkPath = path.join(skillsDir, name);
+    const status = getSymlinkStatus(linkPath);
+
+    if (!status.exists) {
+      logger.status('  \u2717', `${name}: BROKEN (target not found)`);
+      brokenCount++;
+      issues++;
+    } else if (!status.isLink) {
+      logger.status('  \u26a0', `${name}: not a symlink (may be a copied directory)`);
+      warnings++;
+    } else if (status.isValid && status.hasSkillMd) {
+      okCount++;
+    } else {
+      logger.status('  \u26a0', `${name}: SKILL.md missing`);
+      warnings++;
+    }
+  }
+
+  if (skills.length > 0 && brokenCount === 0) {
+    logger.status('  \u2713', `${okCount} skills installed, all valid`);
+  }
+  console.log();
+
+  // Summary
+  logger.header('Summary:');
+  logger.status('  ', `${skills.length} total, ${okCount} ok, ${brokenCount} broken, ${warnings} warnings, ${issues} issues`);
+
+  if (issues > 0 || warnings > 0) {
+    console.log();
+    if (brokenCount > 0) {
+      logger.info('Run "kungeskill remove <name>" to clean broken links');
+    }
+    if (!isCacheValid()) {
+      logger.info('Run "kungeskill init" to initialize the marketplace cache');
+    }
+  }
+}
+
+module.exports = { cmdDoctor };

package/src/commands/init.js

@@ -0,0 +1,44 @@
+'use strict';
+
+const path = require('path');
+const { getConfig, saveConfig } = require('../core/config');
+const { getCacheDir, ensureCacheDir, isCacheValid } = require('../core/cache');
+const { cloneRepo } = require('../utils/git');
+const logger = require('../utils/logger');
+
+async function cmdInit() {
+  const config = getConfig();
+
+  if (isCacheValid()) {
+    logger.success('Marketplace cache already initialized');
+    logger.dim(`  Location: ${getCacheDir()}`);
+    return;
+  }
+
+  const { url, branch } = config.marketplace;
+  logger.info(`Cloning marketplace from ${url} (${branch})...`);
+
+  ensureCacheDir();
+
+  try {
+    await cloneRepo(url, getCacheDir(), branch);
+
+    config.marketplace.cloned = true;
+    config.marketplace.lastSync = new Date().toISOString();
+    saveConfig(config);
+
+    logger.success('Marketplace cached');
+    logger.dim(`  Location: ${getCacheDir()}`);
+  } catch (err) {
+    // Clean up on failure
+    const fs = require('fs');
+    const cacheDir = getCacheDir();
+    if (fs.existsSync(cacheDir)) {
+      fs.rmSync(cacheDir, { recursive: true, force: true });
+    }
+    logger.error(`Failed to clone marketplace: ${err.message}`);
+    process.exit(1);
+  }
+}
+
+module.exports = { cmdInit };

package/src/commands/list.js

@@ -0,0 +1,89 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const { getMarketplaceSourceDir, isCacheValid } = require('../core/cache');
+const { parseMarketplace, listAllSkills } = require('../core/registry');
+const { findProjectSkillsDir } = require('./shared');
+const logger = require('../utils/logger');
+
+function cmdList(opts) {
+  if (!isCacheValid()) {
+    logger.error('Marketplace cache not initialized. Run "kungeskill init" first.');
+    process.exit(1);
+  }
+
+  const cacheDir = getMarketplaceSourceDir();
+  const marketplace = parseMarketplace(cacheDir);
+
+  if (!marketplace) {
+    logger.error('Invalid marketplace manifest. Run "kungeskill init" to reinitialize.');
+    process.exit(1);
+  }
+
+  const showInstalled = opts.installed;
+
+  if (showInstalled) {
+    // Show only installed skills
+    const skillsDir = findProjectSkillsDir();
+    if (!fs.existsSync(skillsDir)) {
+      logger.info('No skills installed in this project.');
+      return;
+    }
+
+    const installed = fs.readdirSync(skillsDir, { withFileTypes: true })
+      .filter(e => e.isDirectory() || e.isSymbolicLink())
+      .map(e => e.name);
+
+    if (installed.length === 0) {
+      logger.info('No skills installed in this project.');
+      return;
+    }
+
+    logger.header('Installed skills in this project:');
+    console.log();
+    for (const name of installed) {
+      console.log(`  ${name}`);
+    }
+    return;
+  }
+
+  // Show all available skills grouped by plugin
+  const skills = listAllSkills(marketplace, cacheDir);
+
+  if (skills.length === 0) {
+    logger.info('No skills found in marketplace.');
+    return;
+  }
+
+  // Group by plugin
+  const grouped = {};
+  for (const skill of skills) {
+    if (!grouped[skill.pluginName]) {
+      grouped[skill.pluginName] = [];
+    }
+    grouped[skill.pluginName].push(skill.skillName);
+  }
+
+  logger.header('Available skills:');
+  console.log();
+
+  const headers = ['PLUGIN', 'SKILLS'];
+  const rows = [];
+
+  let first = true;
+  for (const [plugin, skillNames] of Object.entries(grouped)) {
+    if (!first) {
+      rows.push(['', '']);
+    }
+    rows.push([plugin, skillNames[0]]);
+    for (let i = 1; i < skillNames.length; i++) {
+      rows.push(['', skillNames[i]]);
+    }
+    first = false;
+  }
+
+  logger.table(headers, rows);
+}
+
+module.exports = { cmdList };

package/src/commands/remove.js

@@ -0,0 +1,40 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const { removeSkillSymlink } = require('../core/symlink');
+const { findProjectSkillsDir } = require('./shared');
+const logger = require('../utils/logger');
+
+function cmdRemove(skillName) {
+  const skillsDir = findProjectSkillsDir();
+  const linkPath = path.join(skillsDir, skillName);
+
+  if (!fs.existsSync(linkPath)) {
+    logger.error(`Skill '${skillName}' is not installed in this project.`);
+    process.exit(1);
+  }
+
+  // Check if it's a symlink
+  const stat = fs.lstatSync(linkPath);
+  if (stat.isSymbolicLink()) {
+    // Safe to remove — it's a symlink
+    try {
+      removeSkillSymlink(linkPath);
+      logger.success(`Removed ${skillName}`);
+    } catch (err) {
+      logger.error(`Failed to remove '${skillName}': ${err.message}`);
+      process.exit(1);
+    }
+  } else if (stat.isDirectory()) {
+    // Not a symlink — could be a copied directory. Remove with warning.
+    logger.warn(`'${skillName}' is not a symlink (copied directory). Removing anyway.`);
+    fs.rmSync(linkPath, { recursive: true, force: true });
+    logger.success(`Removed ${skillName}`);
+  } else {
+    logger.error(`'${skillName}' is an unexpected file type, refusing to remove.`);
+    process.exit(1);
+  }
+}
+
+module.exports = { cmdRemove };

package/src/commands/shared.js

@@ -0,0 +1,34 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+
+/**
+ * Find the project's .claude/skills/ directory.
+ * Walks up from cwd until it finds one, or creates it at cwd.
+ *
+ * @param {string} [cwd] - Starting directory (defaults to process.cwd())
+ * @returns {string} Absolute path to .claude/skills/
+ */
+function findProjectSkillsDir(cwd) {
+  cwd = cwd || process.cwd();
+  let dir = path.resolve(cwd);
+  const root = path.parse(dir).root;
+
+  while (dir !== root) {
+    const skillsDir = path.join(dir, '.claude', 'skills');
+    if (fs.existsSync(skillsDir)) {
+      return skillsDir;
+    }
+    dir = path.dirname(dir);
+  }
+
+  // Not found — create at current working directory
+  const skillsDir = path.join(cwd, '.claude', 'skills');
+  fs.mkdirSync(skillsDir, { recursive: true });
+  return skillsDir;
+}
+
+module.exports = {
+  findProjectSkillsDir
+};

package/src/commands/update.js

@@ -0,0 +1,37 @@
+'use strict';
+
+const { getConfig, saveConfig } = require('../core/config');
+const { getCacheDir, isCacheValid } = require('../core/cache');
+const { pullRepo } = require('../utils/git');
+const logger = require('../utils/logger');
+
+async function cmdUpdate() {
+  if (!isCacheValid()) {
+    logger.error('Marketplace cache not initialized. Run "kungeskill init" first.');
+    process.exit(1);
+  }
+
+  const config = getConfig();
+  logger.info('Updating marketplace cache...');
+
+  try {
+    const result = await pullRepo(getCacheDir());
+
+    config.marketplace.lastSync = new Date().toISOString();
+    saveConfig(config);
+
+    // Parse output for summary
+    const output = (result.stdout || '').trim();
+    if (output) {
+      logger.dim(`  ${output}`);
+    }
+
+    logger.success('Marketplace updated');
+    logger.info('Symlinks automatically point to updated content. No reinstallation needed.');
+  } catch (err) {
+    logger.error(`Failed to update marketplace: ${err.message}`);
+    process.exit(1);
+  }
+}
+
+module.exports = { cmdUpdate };

package/src/commands/view.js

@@ -0,0 +1,61 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const { getSymlinkStatus } = require('../core/symlink');
+const { findProjectSkillsDir } = require('./shared');
+const logger = require('../utils/logger');
+
+function cmdView() {
+  const skillsDir = findProjectSkillsDir();
+
+  if (!fs.existsSync(skillsDir)) {
+    logger.info('No skills installed in this project.');
+    return;
+  }
+
+  const entries = fs.readdirSync(skillsDir, { withFileTypes: true });
+  const skills = entries
+    .filter(e => e.isDirectory() || e.isSymbolicLink())
+    .map(e => e.name);
+
+  if (skills.length === 0) {
+    logger.info('No skills installed in this project.');
+    return;
+  }
+
+  logger.header(`Skills installed in this project:`);
+  console.log();
+
+  const headers = ['NAME', 'STATUS', 'TARGET'];
+  const rows = [];
+
+  for (const name of skills) {
+    const linkPath = path.join(skillsDir, name);
+    const status = getSymlinkStatus(linkPath);
+
+    let statusIcon;
+    if (!status.exists) {
+      statusIcon = '\u2717 broken'; // ✗
+    } else if (status.isValid && status.hasSkillMd) {
+      statusIcon = '\u2713 ok'; // ✓
+    } else if (status.isValid) {
+      statusIcon = '\u26a0 no SKILL.md'; // ⚠
+    } else {
+      statusIcon = '? unknown';
+    }
+
+    const target = status.target || '(not found)';
+    // Show relative path for readability
+    const homeDir = require('os').homedir();
+    const displayTarget = target.startsWith(homeDir)
+      ? target.replace(homeDir, '~')
+      : target;
+
+    rows.push([name, statusIcon, displayTarget]);
+  }
+
+  logger.table(headers, rows);
+}
+
+module.exports = { cmdView };

package/src/core/cache.js

@@ -0,0 +1,35 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const { getKungeskillsDir, getConfig, saveConfig } = require('./config');
+
+function getCacheDir() {
+  return path.join(getKungeskillsDir(), 'cache', 'marketplace');
+}
+
+function ensureCacheDir() {
+  const cacheDir = getCacheDir();
+  if (!fs.existsSync(cacheDir)) {
+    fs.mkdirSync(cacheDir, { recursive: true });
+  }
+  return cacheDir;
+}
+
+function isCacheValid() {
+  const cacheDir = getCacheDir();
+  const gitDir = path.join(cacheDir, '.git');
+  return fs.existsSync(gitDir);
+}
+
+function getMarketplaceSourceDir() {
+  // The root of the cloned marketplace within the cache
+  return getCacheDir();
+}
+
+module.exports = {
+  getCacheDir,
+  ensureCacheDir,
+  isCacheValid,
+  getMarketplaceSourceDir
+};

package/src/core/config.js

@@ -0,0 +1,56 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+const KUNGESKILLS_DIR = path.join(os.homedir(), '.kungeskills');
+const CONFIG_PATH = path.join(KUNGESKILLS_DIR, 'config.json');
+
+const DEFAULT_CONFIG = {
+  marketplace: {
+    url: 'https://github.com/kunge2013/skills',
+    branch: 'main',
+    cloned: false,
+    lastSync: null
+  }
+};
+
+function getKungeskillsDir() {
+  return KUNGESKILLS_DIR;
+}
+
+function loadConfig() {
+  if (!fs.existsSync(CONFIG_PATH)) {
+    return null;
+  }
+  const raw = fs.readFileSync(CONFIG_PATH, 'utf-8');
+  return JSON.parse(raw);
+}
+
+function saveConfig(config) {
+  if (!fs.existsSync(KUNGESKILLS_DIR)) {
+    fs.mkdirSync(KUNGESKILLS_DIR, { recursive: true });
+  }
+  fs.writeFileSync(CONFIG_PATH, JSON.stringify(config, null, 2), 'utf-8');
+}
+
+function getConfig() {
+  const existing = loadConfig();
+  if (existing) {
+    // Merge with defaults to ensure new fields exist
+    return {
+      marketplace: { ...DEFAULT_CONFIG.marketplace, ...existing.marketplace }
+    };
+  }
+  return { ...DEFAULT_CONFIG };
+}
+
+module.exports = {
+  getKungeskillsDir,
+  loadConfig,
+  saveConfig,
+  getConfig,
+  CONFIG_PATH,
+  KUNGESKILLS_DIR
+};

package/src/core/registry.js

@@ -0,0 +1,68 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+
+/**
+ * Parse marketplace.json from the cache directory.
+ * @param {string} cacheDir - Path to the marketplace cache root
+ * @returns {object|null} Parsed marketplace data or null
+ */
+function parseMarketplace(cacheDir) {
+  const manifestPath = path.join(cacheDir, '.claude-plugin', 'marketplace.json');
+  if (!fs.existsSync(manifestPath)) {
+    return null;
+  }
+  const raw = fs.readFileSync(manifestPath, 'utf-8');
+  return JSON.parse(raw);
+}
+
+/**
+ * List all skills from a parsed marketplace manifest.
+ * @param {object} marketplace - Parsed marketplace.json
+ * @param {string} cacheDir - Path to the marketplace cache root (for resolving source paths)
+ * @returns {Array<{skillName: string, pluginName: string, sourcePath: string}>}
+ */
+function listAllSkills(marketplace, cacheDir) {
+  if (!marketplace || !marketplace.plugins) return [];
+
+  const skills = [];
+  for (const plugin of marketplace.plugins) {
+    const skillsDir = path.resolve(cacheDir, plugin.source, 'skills');
+    if (!fs.existsSync(skillsDir)) continue;
+
+    const entries = fs.readdirSync(skillsDir, { withFileTypes: true });
+    for (const entry of entries) {
+      if (entry.isDirectory()) {
+        const skillPath = path.join(skillsDir, entry.name);
+        // Verify it has SKILL.md
+        if (fs.existsSync(path.join(skillPath, 'SKILL.md'))) {
+          skills.push({
+            skillName: entry.name,
+            pluginName: plugin.name,
+            sourcePath: skillPath
+          });
+        }
+      }
+    }
+  }
+  return skills;
+}
+
+/**
+ * Find a specific skill by name.
+ * @param {object} marketplace - Parsed marketplace.json
+ * @param {string} cacheDir - Path to the marketplace cache root
+ * @param {string} skillName - Skill name to find
+ * @returns {object|null} { skillName, pluginName, sourcePath } or null
+ */
+function findSkill(marketplace, cacheDir, skillName) {
+  const skills = listAllSkills(marketplace, cacheDir);
+  return skills.find(s => s.skillName === skillName) || null;
+}
+
+module.exports = {
+  parseMarketplace,
+  listAllSkills,
+  findSkill
+};

package/src/core/symlink.js

@@ -0,0 +1,158 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+
+/**
+ * Check if target and link are on the same drive (Windows only).
+ * @param {string} targetPath
+ * @param {string} linkPath
+ * @returns {boolean}
+ */
+function canCreateJunction(targetPath, linkPath) {
+  if (process.platform !== 'win32') return true;
+  return path.parse(path.resolve(targetPath)).root === path.parse(path.resolve(linkPath)).root;
+}
+
+/**
+ * Create a cross-platform symlink for a skill.
+ * On Windows: uses junction points (no admin required).
+ * On Linux/macOS: uses standard directory symlinks.
+ *
+ * @param {string} targetAbsPath - Absolute path to the skill source directory
+ * @param {string} linkAbsPath - Absolute path for the symlink
+ * @returns {boolean} True on success
+ * @throws {Error} On failure
+ */
+function createSkillSymlink(targetAbsPath, linkAbsPath) {
+  // Ensure target exists
+  if (!fs.existsSync(targetAbsPath)) {
+    throw new Error(`Target does not exist: ${targetAbsPath}`);
+  }
+
+  // Windows cross-drive check
+  if (process.platform === 'win32' && !canCreateJunction(targetAbsPath, linkAbsPath)) {
+    throw new Error(
+      `Cannot create junction across drives: ${path.parse(targetAbsPath).root} -> ${path.parse(linkAbsPath).root}. ` +
+      'Move the cache to the same drive as the project, or use a different approach.'
+    );
+  }
+
+  const opts = process.platform === 'win32' ? 'junction' : 'dir';
+  fs.symlinkSync(path.resolve(targetAbsPath), linkAbsPath, opts);
+  return true;
+}
+
+/**
+ * Remove a skill symlink safely (does not touch the source).
+ * @param {string} linkAbsPath
+ */
+function removeSkillSymlink(linkAbsPath) {
+  if (!fs.existsSync(linkAbsPath)) {
+    return false;
+  }
+  // lstat to check if it's a symlink itself
+  const stat = fs.lstatSync(linkAbsPath);
+  if (stat.isSymbolicLink()) {
+    fs.unlinkSync(linkAbsPath);
+    return true;
+  }
+  // Not a symlink — don't delete a real directory
+  throw new Error(`Not a symlink, refusing to delete: ${linkAbsPath}`);
+}
+
+/**
+ * Check if a path is a valid symlink (target exists).
+ * @param {string} linkAbsPath
+ * @returns {boolean}
+ */
+function isSymlinkValid(linkAbsPath) {
+  if (!fs.existsSync(linkAbsPath)) return false;
+  const stat = fs.lstatSync(linkAbsPath);
+  if (!stat.isSymbolicLink()) return false;
+  return fs.existsSync(linkAbsPath); // follows the link
+}
+
+/**
+ * Get detailed status of a skill symlink.
+ * @param {string} linkAbsPath
+ * @returns {{isLink: boolean, isValid: boolean, target: string|null, exists: boolean, hasSkillMd: boolean}}
+ */
+function getSymlinkStatus(linkAbsPath) {
+  const result = {
+    isLink: false,
+    isValid: false,
+    target: null,
+    exists: false,
+    hasSkillMd: false
+  };
+
+  if (!fs.existsSync(linkAbsPath) && !fs.lstatSync(linkAbsPath)) {
+    return result;
+  }
+
+  let stat;
+  try {
+    stat = fs.lstatSync(linkAbsPath);
+  } catch {
+    return result;
+  }
+
+  result.isLink = stat.isSymbolicLink();
+
+  if (!result.isLink) {
+    // It exists but isn't a symlink
+    result.exists = true;
+    result.isValid = true;
+    result.target = linkAbsPath;
+    result.hasSkillMd = fs.existsSync(path.join(linkAbsPath, 'SKILL.md'));
+    return result;
+  }
+
+  // It's a symlink
+  try {
+    result.target = fs.readlinkSync(linkAbsPath);
+  } catch {
+    return result;
+  }
+
+  // Check if target exists (follows link)
+  result.exists = fs.existsSync(linkAbsPath);
+
+  if (result.exists) {
+    result.isValid = true;
+    result.hasSkillMd = fs.existsSync(path.join(linkAbsPath, 'SKILL.md'));
+  }
+
+  return result;
+}
+
+/**
+ * Copy a directory recursively (fallback for cross-drive Windows scenario).
+ * @param {string} src
+ * @param {string} dest
+ */
+function copyDirRecursive(src, dest) {
+  if (!fs.existsSync(dest)) {
+    fs.mkdirSync(dest, { recursive: true });
+  }
+  const entries = fs.readdirSync(src, { withFileTypes: true });
+  for (const entry of entries) {
+    const srcPath = path.join(src, entry.name);
+    const destPath = path.join(dest, entry.name);
+    if (entry.isDirectory()) {
+      copyDirRecursive(srcPath, destPath);
+    } else {
+      fs.copyFileSync(srcPath, destPath);
+    }
+  }
+}
+
+module.exports = {
+  createSkillSymlink,
+  removeSkillSymlink,
+  isSymlinkValid,
+  getSymlinkStatus,
+  canCreateJunction,
+  copyDirRecursive
+};

package/src/utils/git.js

@@ -0,0 +1,33 @@
+'use strict';
+
+const { exec } = require('child_process');
+const { promisify } = require('util');
+
+const execAsync = promisify(exec);
+
+/**
+ * Clone a git repository to a target path.
+ * @param {string} url - Repository URL
+ * @param {string} targetPath - Destination directory
+ * @param {string} branch - Branch to clone
+ * @returns {Promise<{stdout: string, stderr: string}>}
+ */
+async function cloneRepo(url, targetPath, branch = 'main') {
+  const cmd = `git clone --branch "${branch}" "${url}" "${targetPath}"`;
+  return execAsync(cmd);
+}
+
+/**
+ * Pull the latest changes in a git repository.
+ * @param {string} cwd - Working directory (repo root)
+ * @returns {Promise<{stdout: string, stderr: string}>}
+ */
+async function pullRepo(cwd) {
+  const cmd = 'git pull';
+  return execAsync(cmd, { cwd });
+}
+
+module.exports = {
+  cloneRepo,
+  pullRepo
+};

package/src/utils/logger.js

@@ -0,0 +1,85 @@
+'use strict';
+
+// ANSI color codes
+const COLORS = {
+  reset: '\x1b[0m',
+  green: '\x1b[32m',
+  red: '\x1b[31m',
+  yellow: '\x1b[33m',
+  cyan: '\x1b[36m',
+  white: '\x1b[37m',
+  gray: '\x1b[90m',
+  bold: '\x1b[1m'
+};
+
+function _colorize(color, msg) {
+  return `${COLORS[color]}${msg}${COLORS.reset}`;
+}
+
+function info(msg) {
+  console.log(_colorize('white', msg));
+}
+
+function success(msg) {
+  console.log(_colorize('green', msg));
+}
+
+function error(msg) {
+  console.error(_colorize('red', msg));
+}
+
+function warn(msg) {
+  console.log(_colorize('yellow', msg));
+}
+
+function status(icon, msg) {
+  console.log(`${icon} ${msg}`);
+}
+
+function dim(msg) {
+  console.log(_colorize('gray', msg));
+}
+
+function header(msg) {
+  console.log(_colorize('bold', msg));
+}
+
+function table(headers, rows) {
+  // Calculate column widths
+  const widths = headers.map((h, i) => {
+    const maxInCol = Math.max(
+      h.length,
+      ...rows.map(r => (r[i] || '').length)
+    );
+    return maxInCol;
+  });
+
+  // Print headers
+  const headerLine = headers
+    .map((h, i) => h.padEnd(widths[i]))
+    .join('  ');
+  console.log(_colorize('bold', headerLine));
+
+  // Print separator
+  const sepLine = widths.map(w => '─'.repeat(w)).join('  ');
+  console.log(_colorize('gray', sepLine));
+
+  // Print rows
+  for (const row of rows) {
+    const line = row
+      .map((cell, i) => (cell || '').padEnd(widths[i]))
+      .join('  ');
+    console.log(line);
+  }
+}
+
+module.exports = {
+  info,
+  success,
+  error,
+  warn,
+  status,
+  dim,
+  header,
+  table
+};