@h1dr0n/skill-pool 0.1.0

package/src/commands/remove.js

@@ -0,0 +1,101 @@
+import chalk from 'chalk';
+import {
+  loadTracker,
+  saveTracker,
+  isInstalled,
+  recordRemove,
+} from '../core/tracker.js';
+import { loadManifest } from '../core/manifest.js';
+import { getAdapter, getAllTargetNames } from '../adapters/index.js';
+
+async function findDependents(packName, tracker) {
+  const dependents = [];
+  const installedPacks = Object.keys(tracker.installed);
+
+  for (const installed of installedPacks) {
+    if (installed === packName) continue;
+    try {
+      const manifest = await loadManifest(installed);
+      if (manifest.depends.includes(packName)) {
+        dependents.push(installed);
+      }
+    } catch {
+      // skip if manifest can't be loaded
+    }
+  }
+
+  return dependents;
+}
+
+function getTargetsForPack(tracker, packName) {
+  const info = tracker.installed[packName];
+  return info?.targets || getAllTargetNames();
+}
+
+async function removeFromAllTargets(packName, targets, projectDir) {
+  let totalRemoved = 0;
+  for (const targetName of targets) {
+    try {
+      const adapter = getAdapter(targetName);
+      const removed = await adapter.remove(packName, projectDir);
+      totalRemoved += removed.length;
+    } catch {
+      // adapter might not have files for this pack
+    }
+  }
+  return totalRemoved;
+}
+
+export async function removeCommand(packName, options) {
+  const projectDir = process.cwd();
+  let tracker = await loadTracker(projectDir);
+
+  if (options.all) {
+    const installedPacks = Object.keys(tracker.installed);
+    if (installedPacks.length === 0) {
+      console.log(chalk.yellow('No packs installed.'));
+      return;
+    }
+
+    for (const name of installedPacks) {
+      const targets = getTargetsForPack(tracker, name);
+      const count = await removeFromAllTargets(name, targets, projectDir);
+      tracker = recordRemove(tracker, name);
+      console.log(
+        chalk.red(`  - ${name}`) + chalk.gray(` (${count} rules removed)`)
+      );
+    }
+
+    await saveTracker(projectDir, tracker);
+    console.log(chalk.green('\nAll packs removed.'));
+    return;
+  }
+
+  if (!packName) {
+    console.error(chalk.red('Please specify a pack name or use --all'));
+    process.exit(1);
+  }
+
+  if (!isInstalled(tracker, packName)) {
+    console.log(chalk.yellow(`Pack "${packName}" is not installed.`));
+    return;
+  }
+
+  const dependents = await findDependents(packName, tracker);
+  if (dependents.length > 0) {
+    console.log(
+      chalk.yellow(
+        `Warning: pack(s) ${dependents.map((d) => `"${d}"`).join(', ')} depend on "${packName}". Consider removing them first.`
+      )
+    );
+  }
+
+  const targets = getTargetsForPack(tracker, packName);
+  const count = await removeFromAllTargets(packName, targets, projectDir);
+  tracker = recordRemove(tracker, packName);
+  await saveTracker(projectDir, tracker);
+
+  console.log(
+    chalk.red(`  - ${packName}`) + chalk.gray(` (${count} rules removed)`)
+  );
+}

package/src/commands/targets.js

@@ -0,0 +1,32 @@
+import chalk from 'chalk';
+import { getAllTargetNames, detectTargets } from '../adapters/index.js';
+
+const CONFIG_DIRS = {
+  claude: '.claude/',
+  cursor: '.cursor/',
+  windsurf: '.windsurf/',
+  antigravity: '.agent/',
+};
+
+export async function targetsCommand() {
+  const allTargets = getAllTargetNames();
+  const detected = await detectTargets(process.cwd());
+  const detectedSet = new Set(detected);
+
+  const maxNameLen = Math.max(...allTargets.map((name) => name.length));
+
+  console.log(chalk.bold('\nSupported targets:\n'));
+
+  for (const name of allTargets) {
+    const isDetected = detectedSet.has(name);
+    const icon = isDetected ? chalk.green('\u2713') : chalk.gray('-');
+    const displayName = isDetected ? chalk.white(name) : chalk.gray(name);
+    const configDir = CONFIG_DIRS[name] || 'unknown';
+    const displayDir = isDetected ? chalk.white(configDir) : chalk.gray(configDir);
+    const padding = ' '.repeat(maxNameLen - name.length);
+
+    console.log(`  ${icon} ${displayName}${padding}    ${displayDir}`);
+  }
+
+  console.log('');
+}

package/src/commands/update.js

@@ -0,0 +1,57 @@
+import chalk from 'chalk';
+import { loadManifest } from '../core/manifest.js';
+import {
+  loadTracker,
+  saveTracker,
+  recordInstall,
+} from '../core/tracker.js';
+import { getAdapter } from '../adapters/index.js';
+
+export async function updateCommand(packName) {
+  const projectDir = process.cwd();
+  let tracker = await loadTracker(projectDir);
+  const installedPacks = Object.keys(tracker.installed);
+
+  if (installedPacks.length === 0) {
+    console.log(chalk.yellow('No packs installed.'));
+    return;
+  }
+
+  const toUpdate = packName ? [packName] : installedPacks;
+  let updatedCount = 0;
+
+  for (const name of toUpdate) {
+    const info = tracker.installed[name];
+    if (!info) {
+      console.log(chalk.yellow(`Pack "${name}" is not installed.`));
+      continue;
+    }
+
+    const manifest = await loadManifest(name);
+    const targets = info.targets || ['claude'];
+
+    // Re-install to pick up content changes
+    let totalFiles = 0;
+    for (const targetName of targets) {
+      const adapter = getAdapter(targetName);
+      const files = await adapter.install(manifest, projectDir);
+      totalFiles += files.length;
+    }
+
+    tracker = recordInstall(tracker, name, manifest.version, targets);
+    updatedCount++;
+
+    const versionChanged = info.version !== manifest.version;
+    const label = versionChanged
+      ? `${info.version} -> ${manifest.version}`
+      : manifest.version;
+
+    console.log(
+      chalk.green(`  ~ ${name}@${label}`) +
+        chalk.gray(` (${totalFiles} rules)`)
+    );
+  }
+
+  await saveTracker(projectDir, tracker);
+  console.log(chalk.green(`\nUpdated ${updatedCount} pack(s).`));
+}

package/src/core/manifest.js

@@ -0,0 +1,57 @@
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import yaml from 'js-yaml';
+import { readFileContent, listDir } from '../utils/fs.js';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const SKILLS_DIR = path.resolve(__dirname, '..', '..', 'skills');
+
+export function getSkillsDir() {
+  return SKILLS_DIR;
+}
+
+export async function loadManifest(packName) {
+  const manifestPath = path.join(SKILLS_DIR, packName, 'manifest.yaml');
+  const content = await readFileContent(manifestPath);
+  const manifest = yaml.load(content);
+
+  if (!manifest.name) {
+    throw new Error(`Manifest for "${packName}" is missing required field: name`);
+  }
+
+  const hasContent =
+    (manifest.rules && manifest.rules.length > 0) ||
+    (manifest.skills && manifest.skills.length > 0) ||
+    (manifest.agents && manifest.agents.length > 0);
+
+  if (!hasContent) {
+    throw new Error(`Manifest for "${packName}" must have at least one of: rules, skills, agents`);
+  }
+
+  return {
+    name: manifest.name,
+    version: manifest.version || '0.0.0',
+    description: manifest.description || '',
+    depends: manifest.depends || [],
+    tags: manifest.tags || [],
+    rules: manifest.rules || [],
+    skills: manifest.skills || [],
+    agents: manifest.agents || [],
+  };
+}
+
+export async function listAvailablePacks() {
+  const entries = await listDir(SKILLS_DIR);
+  const packs = [];
+
+  for (const entry of entries) {
+    try {
+      const manifest = await loadManifest(entry);
+      packs.push(manifest);
+    } catch {
+      // skip directories without valid manifests
+    }
+  }
+
+  return packs;
+}

package/src/core/plugins.js

@@ -0,0 +1,86 @@
+import path from 'node:path';
+import { readFileContent } from '../utils/fs.js';
+
+const CONFIG_FILES = ['.skillpoolrc.json', 'skillpool.config.js'];
+
+/**
+ * Load plugin configuration from project root.
+ * Looks for .skillpoolrc.json or skillpool.config.js.
+ *
+ * @param {string} projectDir - absolute path to the project root
+ * @returns {Promise<{ adapters: Record<string, string> }>}
+ */
+async function loadConfig(projectDir) {
+  // Try .skillpoolrc.json first
+  try {
+    const jsonPath = path.join(projectDir, CONFIG_FILES[0]);
+    const content = await readFileContent(jsonPath);
+    const config = JSON.parse(content);
+    return { adapters: config.adapters || {} };
+  } catch {
+    // not found or invalid, try next
+  }
+
+  // Try skillpool.config.js
+  try {
+    const jsPath = path.join(projectDir, CONFIG_FILES[1]);
+    const fileUrl = 'file:///' + jsPath.replace(/\\/g, '/');
+    const mod = await import(fileUrl);
+    const config = mod.default || mod;
+    return { adapters: config.adapters || {} };
+  } catch {
+    // not found or invalid
+  }
+
+  return { adapters: {} };
+}
+
+const REQUIRED_METHODS = ['detect', 'install', 'remove', 'list'];
+
+/**
+ * Validate that a custom adapter exports the required interface.
+ *
+ * @param {object} adapter - the imported adapter module
+ * @param {string} name - adapter name for error messages
+ */
+function validateAdapter(adapter, name) {
+  for (const method of REQUIRED_METHODS) {
+    if (typeof adapter[method] !== 'function') {
+      throw new Error(
+        `Custom adapter "${name}" is missing required method: ${method}`
+      );
+    }
+  }
+}
+
+/**
+ * Load custom adapters defined in the project config file.
+ *
+ * @param {string} projectDir - absolute path to the project root
+ * @returns {Promise<Record<string, object>>} map of adapter name to adapter module
+ */
+export async function loadPlugins(projectDir) {
+  const config = await loadConfig(projectDir);
+  const customAdapters = {};
+
+  for (const [name, adapterPath] of Object.entries(config.adapters)) {
+    const resolvedPath = path.resolve(projectDir, adapterPath);
+    const fileUrl = 'file:///' + resolvedPath.replace(/\\/g, '/');
+
+    try {
+      const mod = await import(fileUrl);
+      const adapter = mod.default || mod;
+      validateAdapter(adapter, name);
+      customAdapters[name] = adapter;
+    } catch (err) {
+      if (err.message.includes('missing required method')) {
+        throw err;
+      }
+      throw new Error(
+        `Failed to load custom adapter "${name}" from ${adapterPath}: ${err.message}`
+      );
+    }
+  }
+
+  return customAdapters;
+}

package/src/core/resolver.js

@@ -0,0 +1,84 @@
+import { loadManifest } from './manifest.js';
+
+export async function resolveDependencies(packName) {
+  const resolved = [];
+  const visited = new Set();
+  const visiting = new Set();
+
+  async function visit(name) {
+    if (resolved.includes(name)) return;
+
+    if (visiting.has(name)) {
+      throw new Error(`Circular dependency detected: ${name}`);
+    }
+
+    visiting.add(name);
+    const manifest = await loadManifest(name);
+
+    for (const dep of manifest.depends) {
+      await visit(dep);
+    }
+
+    visiting.delete(name);
+    visited.add(name);
+    resolved.push(name);
+  }
+
+  await visit(packName);
+  return resolved;
+}
+
+/**
+ * Check for version conflicts across multiple packs' dependency trees.
+ *
+ * For each requested pack, resolves its full dependency tree and records
+ * which version each dependency has. If a dependency appears in multiple
+ * trees with different versions, it is reported as a conflict.
+ *
+ * @param {string[]} packNames - list of top-level pack names to install
+ * @returns {Promise<Array<{ dep: string, versions: string[], requestedBy: string[] }>>}
+ */
+export async function checkConflicts(packNames) {
+  // Map: dep name -> Map<version, Set<requestedBy>>
+  const depVersions = new Map();
+
+  for (const packName of packNames) {
+    const deps = await resolveDependencies(packName);
+
+    for (const depName of deps) {
+      const manifest = await loadManifest(depName);
+      const version = manifest.version;
+
+      if (!depVersions.has(depName)) {
+        depVersions.set(depName, new Map());
+      }
+
+      const versionMap = depVersions.get(depName);
+      if (!versionMap.has(version)) {
+        versionMap.set(version, new Set());
+      }
+      versionMap.get(version).add(packName);
+    }
+  }
+
+  const conflicts = [];
+
+  for (const [dep, versionMap] of depVersions) {
+    if (versionMap.size > 1) {
+      const versions = [...versionMap.keys()].sort();
+      const requestedBy = new Set();
+      for (const requesterSet of versionMap.values()) {
+        for (const requester of requesterSet) {
+          requestedBy.add(requester);
+        }
+      }
+      conflicts.push({
+        dep,
+        versions,
+        requestedBy: [...requestedBy],
+      });
+    }
+  }
+
+  return conflicts;
+}

package/src/core/tracker.js

@@ -0,0 +1,49 @@
+import path from 'node:path';
+import { readFileContent, writeFileAtomic, fileExists } from '../utils/fs.js';
+
+const TRACKER_FILE = '.skillpool.json';
+
+function defaultTracker() {
+  return { version: '1.0.0', installed: {} };
+}
+
+export async function loadTracker(projectDir) {
+  const filePath = path.join(projectDir, TRACKER_FILE);
+  if (!(await fileExists(filePath))) {
+    return defaultTracker();
+  }
+  const content = await readFileContent(filePath);
+  return JSON.parse(content);
+}
+
+export async function saveTracker(projectDir, data) {
+  const filePath = path.join(projectDir, TRACKER_FILE);
+  await writeFileAtomic(filePath, JSON.stringify(data, null, 2) + '\n');
+}
+
+export function isInstalled(trackerData, packName) {
+  return packName in trackerData.installed;
+}
+
+export function getInstalledVersion(trackerData, packName) {
+  return trackerData.installed[packName]?.version || null;
+}
+
+export function recordInstall(trackerData, packName, version, targets) {
+  return {
+    ...trackerData,
+    installed: {
+      ...trackerData.installed,
+      [packName]: {
+        version,
+        installedAt: new Date().toISOString(),
+        targets,
+      },
+    },
+  };
+}
+
+export function recordRemove(trackerData, packName) {
+  const { [packName]: _, ...rest } = trackerData.installed;
+  return { ...trackerData, installed: rest };
+}

package/src/utils/fs.js

@@ -0,0 +1,80 @@
+import { mkdir, writeFile, readFile, unlink, stat, readdir, rm, cp } from 'node:fs/promises';
+import path from 'node:path';
+
+export async function ensureDir(dirPath) {
+  await mkdir(dirPath, { recursive: true });
+}
+
+export async function writeFileAtomic(filePath, content) {
+  await ensureDir(path.dirname(filePath));
+  await writeFile(filePath, content, 'utf-8');
+}
+
+export async function readFileContent(filePath) {
+  return readFile(filePath, 'utf-8');
+}
+
+export async function removeFile(filePath) {
+  try {
+    await unlink(filePath);
+    return true;
+  } catch (err) {
+    if (err.code === 'ENOENT') return false;
+    throw err;
+  }
+}
+
+export async function fileExists(filePath) {
+  try {
+    await stat(filePath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+export async function listDir(dirPath) {
+  try {
+    return await readdir(dirPath);
+  } catch (err) {
+    if (err.code === 'ENOENT') return [];
+    throw err;
+  }
+}
+
+export async function copyDir(src, dest) {
+  await cp(src, dest, { recursive: true });
+}
+
+export async function removeDir(dirPath) {
+  try {
+    await rm(dirPath, { recursive: true, force: true });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+export async function isDirectory(filePath) {
+  try {
+    const s = await stat(filePath);
+    return s.isDirectory();
+  } catch {
+    return false;
+  }
+}
+
+export async function listDirRecursive(dirPath) {
+  const results = [];
+  const entries = await listDir(dirPath);
+  for (const entry of entries) {
+    const fullPath = path.join(dirPath, entry);
+    if (await isDirectory(fullPath)) {
+      const subEntries = await listDirRecursive(fullPath);
+      results.push(...subEntries);
+    } else {
+      results.push(fullPath);
+    }
+  }
+  return results;
+}

package/src/utils/git.js

@@ -0,0 +1,52 @@
+import { execFile } from 'node:child_process';
+
+/**
+ * Run a git command and return stdout.
+ * @param {string[]} args - git subcommand and arguments
+ * @param {object} [options] - execFile options (cwd, etc.)
+ * @returns {Promise<string>}
+ */
+function runGit(args, options = {}) {
+  return new Promise((resolve, reject) => {
+    execFile('git', args, { timeout: 60_000, ...options }, (error, stdout, stderr) => {
+      if (error) {
+        const message = stderr?.trim() || error.message;
+        reject(new Error(`git ${args[0]} failed: ${message}`));
+        return;
+      }
+      resolve(stdout.trim());
+    });
+  });
+}
+
+/**
+ * Clone a repository with --depth 1.
+ * @param {string} url - Repository URL
+ * @param {string} dest - Destination directory
+ * @param {string} [branch] - Optional branch or tag to clone
+ * @returns {Promise<void>}
+ */
+export async function cloneRepo(url, dest, branch) {
+  const args = ['clone', '--depth', '1'];
+
+  if (branch) {
+    args.push('--branch', branch);
+  }
+
+  args.push(url, dest);
+
+  await runGit(args);
+}
+
+/**
+ * Check whether git is available on the system.
+ * @returns {Promise<boolean>}
+ */
+export async function isGitAvailable() {
+  try {
+    await runGit(['--version']);
+    return true;
+  } catch {
+    return false;
+  }
+}