@h1dr0n/skill-pool 0.1.0

package/src/commands/create.js

@@ -0,0 +1,127 @@
+import path from 'node:path';
+import chalk from 'chalk';
+import { ensureDir, writeFileAtomic, fileExists } from '../utils/fs.js';
+
+const MANIFEST_TEMPLATE = (name) => `name: ${name}
+version: 0.1.0
+description: "${name} skill pack"
+depends:
+  - common
+tags:
+  - ${name}
+rules: []
+skills:
+  - skills/example.md
+agents:
+  - agents/example.md
+`;
+
+const SKILL_TEMPLATE = `---
+name: example
+description: Example skill - replace with your skill description. Use when...
+---
+
+# Example Skill
+
+## When to Activate
+- Describe when this skill should be used
+
+## Content
+- Add your skill content here
+`;
+
+const AGENT_TEMPLATE = `---
+name: example-agent
+description: Example agent - replace with your agent description
+tools: ["Read", "Write", "Edit", "Glob", "Grep"]
+model: sonnet
+---
+
+You are an expert in...
+
+## Core Mission
+- Describe what this agent does
+
+## Rules
+- Add agent-specific rules
+`;
+
+const README_TEMPLATE = (name) => `# ${name}
+
+A skill pack for agent-skill-pool.
+
+## Structure
+
+\`\`\`
+${name}/
+├── manifest.yaml   # Pack metadata, dependencies, and file listings
+├── rules/          # Rule files (.md) installed to AI tool config
+├── skills/         # Skill files (.md) with frontmatter metadata
+├── agents/         # Agent files (.md) with frontmatter metadata
+└── README.md       # This file
+\`\`\`
+
+## manifest.yaml
+
+The manifest defines the pack name, version, description, dependencies,
+tags, and lists all rules, skills, and agents included in the pack.
+
+## File Format
+
+### Skills
+
+Skills use YAML frontmatter with \`name\` and \`description\` fields,
+followed by markdown content describing when and how to use the skill.
+
+### Agents
+
+Agents use YAML frontmatter with \`name\`, \`description\`, \`tools\`,
+and \`model\` fields, followed by a system prompt in markdown.
+
+### Rules
+
+Rules are plain markdown files installed into the AI tool's
+configuration directory.
+
+## Getting Started
+
+1. Edit \`manifest.yaml\` with your pack details
+2. Add rules to \`rules/\`
+3. Edit or add skills in \`skills/\`
+4. Edit or add agents in \`agents/\`
+5. Install with: \`skill-pool install ${name}\`
+`;
+
+export async function createCommand(name, options) {
+  const baseDir = path.resolve(options.path);
+  const packDir = path.join(baseDir, name);
+
+  if (await fileExists(packDir)) {
+    throw new Error(`Directory already exists: ${packDir}`);
+  }
+
+  await ensureDir(path.join(packDir, 'rules'));
+  await writeFileAtomic(path.join(packDir, 'manifest.yaml'), MANIFEST_TEMPLATE(name));
+  await writeFileAtomic(path.join(packDir, 'skills', 'example.md'), SKILL_TEMPLATE);
+  await writeFileAtomic(path.join(packDir, 'agents', 'example.md'), AGENT_TEMPLATE);
+  await writeFileAtomic(path.join(packDir, 'README.md'), README_TEMPLATE(name));
+
+  console.log(chalk.green(`\nCreated skill pack "${name}" at ${packDir}\n`));
+  console.log(chalk.bold('Structure:\n'));
+  console.log(`  ${chalk.cyan(name)}/`);
+  console.log(`  ├── manifest.yaml`);
+  console.log(`  ├── rules/`);
+  console.log(`  ├── skills/`);
+  console.log(`  │   └── example.md`);
+  console.log(`  ├── agents/`);
+  console.log(`  │   └── example.md`);
+  console.log(`  └── README.md`);
+  console.log('');
+  console.log(chalk.bold('Next steps:\n'));
+  console.log(`  1. Edit ${chalk.cyan('manifest.yaml')} with your pack details`);
+  console.log(`  2. Add rules to ${chalk.cyan('rules/')}`);
+  console.log(`  3. Edit or add skills in ${chalk.cyan('skills/')}`);
+  console.log(`  4. Edit or add agents in ${chalk.cyan('agents/')}`);
+  console.log(`  5. Install with: ${chalk.cyan(`skill-pool install ${name}`)}`);
+  console.log('');
+}

package/src/commands/diff.js

@@ -0,0 +1,78 @@
+import chalk from 'chalk';
+import { loadManifest } from '../core/manifest.js';
+import { loadTracker, isInstalled } from '../core/tracker.js';
+
+export async function diffCommand(packName) {
+  const projectDir = process.cwd();
+  const tracker = await loadTracker(projectDir);
+
+  if (!isInstalled(tracker, packName)) {
+    console.log(
+      chalk.yellow(`Pack "${packName}" is not installed. Use \`skill-pool install ${packName}\` first.`)
+    );
+    return;
+  }
+
+  let manifest;
+  try {
+    manifest = await loadManifest(packName);
+  } catch {
+    console.log(chalk.red(`Could not load manifest for "${packName}". Pack may no longer exist.`));
+    return;
+  }
+
+  const installed = tracker.installed[packName];
+  const installedVersion = installed.version;
+  const availableVersion = manifest.version;
+  const installedDate = new Date(installed.installedAt).toLocaleDateString();
+
+  console.log(chalk.bold(`\nDiff for ${packName}:\n`));
+
+  console.log(`  Installed: ${chalk.cyan(installedVersion)} (${installedDate})`);
+  console.log(`  Available: ${chalk.cyan(availableVersion)}`);
+
+  if (installedVersion === availableVersion) {
+    console.log(chalk.green('\n  Same version - no update available.\n'));
+  } else {
+    console.log(chalk.yellow(`\n  Version change: ${installedVersion} -> ${availableVersion}\n`));
+  }
+
+  const installedTargets = installed.targets || [];
+  const manifestItems = collectItems(manifest);
+
+  console.log(chalk.bold('  Contents in latest manifest:\n'));
+
+  if (manifestItems.length === 0) {
+    console.log(chalk.gray('    (no items)'));
+  } else {
+    for (const item of manifestItems) {
+      const symbol = installedVersion === availableVersion
+        ? chalk.gray('  ')
+        : chalk.yellow('~ ');
+      console.log(`    ${symbol}${chalk.white(item.path)} ${chalk.gray(`(${item.type})`)}`);
+    }
+  }
+
+  if (installedTargets.length > 0) {
+    console.log(chalk.bold('\n  Installed targets:'));
+    console.log(`    ${chalk.gray(installedTargets.join(', '))}`);
+  }
+
+  console.log('');
+}
+
+function collectItems(manifest) {
+  const items = [];
+
+  for (const rule of manifest.rules) {
+    items.push({ path: rule, type: 'rule' });
+  }
+  for (const skill of manifest.skills) {
+    items.push({ path: skill, type: 'skill' });
+  }
+  for (const agent of manifest.agents) {
+    items.push({ path: agent, type: 'agent' });
+  }
+
+  return items;
+}

package/src/commands/info.js

@@ -0,0 +1,88 @@
+import chalk from 'chalk';
+import { loadManifest } from '../core/manifest.js';
+import { loadTracker } from '../core/tracker.js';
+import { resolveDependencies } from '../core/resolver.js';
+
+export async function infoCommand(packName) {
+  const manifest = await loadManifest(packName);
+
+  const projectDir = process.cwd();
+  const tracker = await loadTracker(projectDir);
+  const installInfo = tracker.installed[packName] || null;
+
+  // Header
+  console.log(chalk.bold(`\n${manifest.name}`) + chalk.gray(`@${manifest.version}`));
+  if (manifest.description) {
+    console.log(chalk.gray(manifest.description));
+  }
+  console.log('');
+
+  // Tags
+  if (manifest.tags.length > 0) {
+    console.log(chalk.bold('Tags:'));
+    console.log(`  ${manifest.tags.map((t) => chalk.cyan(t)).join(', ')}`);
+    console.log('');
+  }
+
+  // Dependencies
+  console.log(chalk.bold('Dependencies:'));
+  if (manifest.depends.length === 0) {
+    console.log(chalk.gray('  None'));
+  } else {
+    const resolved = await resolveDependencies(packName);
+    // Remove the pack itself from the resolved chain
+    const chain = resolved.filter((d) => d !== packName);
+    console.log(`  Direct: ${manifest.depends.map((d) => chalk.cyan(d)).join(', ')}`);
+    if (chain.length > manifest.depends.length) {
+      console.log(`  Resolved chain: ${chain.map((d) => chalk.cyan(d)).join(' → ')}`);
+    }
+  }
+  console.log('');
+
+  // Rules
+  console.log(chalk.bold(`Rules (${manifest.rules.length}):`));
+  if (manifest.rules.length === 0) {
+    console.log(chalk.gray('  None'));
+  } else {
+    for (const rule of manifest.rules) {
+      console.log(`  ${chalk.white(rule)}`);
+    }
+  }
+  console.log('');
+
+  // Skills
+  console.log(chalk.bold(`Skills (${manifest.skills.length}):`));
+  if (manifest.skills.length === 0) {
+    console.log(chalk.gray('  None'));
+  } else {
+    for (const skill of manifest.skills) {
+      const isDir = !skill.endsWith('.md');
+      const label = isDir ? chalk.white(skill) + chalk.gray(' (directory)') : chalk.white(skill);
+      console.log(`  ${label}`);
+    }
+  }
+  console.log('');
+
+  // Agents
+  console.log(chalk.bold(`Agents (${manifest.agents.length}):`));
+  if (manifest.agents.length === 0) {
+    console.log(chalk.gray('  None'));
+  } else {
+    for (const agent of manifest.agents) {
+      console.log(`  ${chalk.white(agent)}`);
+    }
+  }
+  console.log('');
+
+  // Install status
+  console.log(chalk.bold('Install status:'));
+  if (installInfo) {
+    const date = new Date(installInfo.installedAt).toLocaleDateString();
+    const targets = installInfo.targets ? installInfo.targets.join(', ') : 'N/A';
+    console.log(`  ${chalk.green('Installed')} v${installInfo.version} on ${date}`);
+    console.log(`  Targets: ${targets}`);
+  } else {
+    console.log(chalk.gray('  Not installed'));
+  }
+  console.log('');
+}

package/src/commands/init.js

@@ -0,0 +1,224 @@
+import path from 'node:path';
+import chalk from 'chalk';
+import { fileExists, listDir, ensureDir, readFileContent } from '../utils/fs.js';
+import { detectTargets } from '../adapters/index.js';
+import { listAvailablePacks } from '../core/manifest.js';
+import { installCommand } from './install.js';
+
+const PROJECT_DETECTORS = [
+  {
+    pack: 'unity',
+    files: ['*.unity'],
+    extensions: ['.cs'],
+    description: 'Unity project detected',
+  },
+  {
+    pack: 'unreal',
+    files: ['*.uproject'],
+    extensions: [],
+    description: 'Unreal Engine project detected',
+  },
+  {
+    pack: 'web',
+    files: ['package.json'],
+    extensions: [],
+    packageJsonMatch: /["'](?:react|next|vue|nuxt|svelte|astro)["']/,
+    description: 'Web/frontend project detected',
+  },
+  {
+    pack: 'python',
+    files: ['requirements.txt', 'pyproject.toml', 'setup.py'],
+    extensions: ['.py'],
+    description: 'Python project detected',
+  },
+  {
+    pack: 'django',
+    files: ['manage.py'],
+    extensions: [],
+    requirementsMatch: /django/i,
+    description: 'Django project detected',
+  },
+  {
+    pack: 'go',
+    files: ['go.mod'],
+    extensions: [],
+    description: 'Go project detected',
+  },
+  {
+    pack: 'rust',
+    files: ['Cargo.toml'],
+    extensions: [],
+    description: 'Rust project detected',
+  },
+  {
+    pack: 'swift',
+    files: ['Package.swift'],
+    extensions: ['.swift'],
+    description: 'Swift project detected',
+  },
+  {
+    pack: 'kotlin',
+    files: ['build.gradle', 'build.gradle.kts'],
+    extensions: ['.kt'],
+    description: 'Kotlin project detected',
+  },
+  {
+    pack: 'java',
+    files: ['pom.xml'],
+    extensions: ['.java'],
+    description: 'Java project detected',
+  },
+  {
+    pack: 'laravel',
+    files: ['composer.json'],
+    extensions: [],
+    description: 'Laravel/PHP project detected',
+  },
+  {
+    pack: 'devops',
+    files: ['Dockerfile', 'docker-compose.yml', 'docker-compose.yaml'],
+    extensions: [],
+    description: 'Docker/DevOps project detected',
+  },
+  {
+    pack: 'dotnet',
+    files: ['*.sln'],
+    extensions: ['.csproj'],
+    description: '.NET project detected',
+  },
+  {
+    pack: 'cpp',
+    files: ['CMakeLists.txt'],
+    extensions: ['.cpp', '.cc', '.cxx'],
+    description: 'C++ project detected',
+  },
+];
+
+async function hasFileWithExtension(projectDir, extensions) {
+  const entries = await listDir(projectDir);
+  return entries.some((entry) =>
+    extensions.some((ext) => entry.endsWith(ext))
+  );
+}
+
+async function hasMatchingFile(projectDir, patterns) {
+  const entries = await listDir(projectDir);
+  for (const pattern of patterns) {
+    if (pattern.startsWith('*')) {
+      const ext = pattern.slice(1);
+      if (entries.some((entry) => entry.endsWith(ext))) {
+        return true;
+      }
+    } else {
+      if (entries.includes(pattern)) {
+        return true;
+      }
+    }
+  }
+  return false;
+}
+
+async function detectProjectPacks(projectDir) {
+  const detected = [];
+
+  for (const detector of PROJECT_DETECTORS) {
+    let matched = false;
+
+    if (detector.files.length > 0) {
+      matched = await hasMatchingFile(projectDir, detector.files);
+    }
+
+    if (!matched && detector.extensions && detector.extensions.length > 0) {
+      matched = await hasFileWithExtension(projectDir, detector.extensions);
+    }
+
+    if (matched && detector.packageJsonMatch) {
+      const pkgPath = path.join(projectDir, 'package.json');
+      if (await fileExists(pkgPath)) {
+        const content = await readFileContent(pkgPath);
+        matched = detector.packageJsonMatch.test(content);
+      } else {
+        matched = false;
+      }
+    }
+
+    if (matched && detector.requirementsMatch) {
+      const reqPath = path.join(projectDir, 'requirements.txt');
+      if (await fileExists(reqPath)) {
+        const content = await readFileContent(reqPath);
+        matched = detector.requirementsMatch.test(content);
+      } else {
+        matched = false;
+      }
+    }
+
+    if (matched) {
+      detected.push({ pack: detector.pack, description: detector.description });
+    }
+  }
+
+  return detected;
+}
+
+export async function initCommand(packs = [], options = {}) {
+  const projectDir = process.cwd();
+
+  console.log(chalk.bold('\nSkill Pool - Project Init\n'));
+
+  // Detect AI tool targets
+  let targets = await detectTargets(projectDir);
+  if (targets.length === 0) {
+    console.log(chalk.yellow('No AI tool directories detected. Creating .claude/ as default target.'));
+    await ensureDir(path.join(projectDir, '.claude'));
+    targets = ['claude'];
+  } else {
+    console.log(chalk.green(`Detected targets: ${targets.join(', ')}`));
+  }
+
+  // Get available packs
+  const availablePacks = await listAvailablePacks();
+  const availableNames = availablePacks.map((p) => p.name);
+
+  // Determine which packs to install
+  let packsToInstall = [];
+
+  if (packs.length > 0) {
+    // Validate user-provided pack names
+    const invalid = packs.filter((p) => !availableNames.includes(p));
+    if (invalid.length > 0) {
+      console.error(chalk.red(`\nUnknown pack(s): ${invalid.join(', ')}`));
+      console.log(chalk.gray(`Available: ${availableNames.join(', ')}`));
+      process.exit(1);
+    }
+    packsToInstall = packs;
+  } else {
+    // Auto-detect project type
+    const detected = await detectProjectPacks(projectDir);
+
+    if (detected.length > 0) {
+      console.log(chalk.cyan('\nDetected project types:'));
+      for (const d of detected) {
+        console.log(chalk.cyan(`  - ${d.description} → ${chalk.bold(d.pack)}`));
+      }
+      packsToInstall = detected.map((d) => d.pack);
+    } else {
+      console.log(chalk.yellow('\nNo project type detected automatically.'));
+      console.log(chalk.gray(`Available packs: ${availableNames.join(', ')}`));
+      console.log(chalk.gray('Run: skill-pool init <pack1> <pack2> ...'));
+      return;
+    }
+  }
+
+  // Always include common pack if available and not already listed
+  if (availableNames.includes('common') && !packsToInstall.includes('common')) {
+    packsToInstall.unshift('common');
+  }
+
+  console.log(chalk.bold(`\nInstalling packs: ${packsToInstall.join(', ')}\n`));
+
+  await installCommand(packsToInstall, {
+    target: options.target || targets.join(','),
+  });
+
+  console.log(chalk.green('\nProject initialized successfully.'));
+}

package/src/commands/install.js

@@ -0,0 +1,90 @@
+import chalk from 'chalk';
+import { resolveDependencies, checkConflicts } from '../core/resolver.js';
+import { loadManifest } from '../core/manifest.js';
+import {
+  loadTracker,
+  saveTracker,
+  getInstalledVersion,
+  recordInstall,
+} from '../core/tracker.js';
+import { getAdapter, detectTargets, getAllTargetNames } from '../adapters/index.js';
+
+async function resolveTargets(projectDir, targetOption) {
+  if (targetOption) {
+    const names = targetOption.split(',').map((t) => t.trim());
+    names.forEach((n) => getAdapter(n)); // validate
+    return names;
+  }
+
+  const detected = await detectTargets(projectDir);
+  if (detected.length > 0) return detected;
+
+  // Default to claude if nothing detected
+  return ['claude'];
+}
+
+export async function installCommand(packNames, options = {}) {
+  const projectDir = process.cwd();
+  const targets = await resolveTargets(projectDir, options.target);
+  let tracker = await loadTracker(projectDir);
+
+  console.log(chalk.gray(`Targets: ${targets.join(', ')}\n`));
+
+  if (packNames.length > 1) {
+    const conflicts = await checkConflicts(packNames);
+    if (conflicts.length > 0) {
+      console.log(chalk.yellow('⚠ Dependency version conflicts detected:\n'));
+      for (const conflict of conflicts) {
+        console.log(
+          chalk.yellow(
+            `  "${conflict.dep}" has versions [${conflict.versions.join(', ')}] ` +
+            `(requested by: ${conflict.requestedBy.join(', ')})`
+          )
+        );
+      }
+      console.log(chalk.yellow('\n  Using latest version for each conflicting dependency.\n'));
+    }
+  }
+
+  const allPacks = new Set();
+  for (const name of packNames) {
+    const deps = await resolveDependencies(name);
+    deps.forEach((d) => allPacks.add(d));
+  }
+
+  const toInstall = [...allPacks];
+  let installedCount = 0;
+
+  for (const packName of toInstall) {
+    const manifest = await loadManifest(packName);
+    const currentVersion = getInstalledVersion(tracker, packName);
+
+    if (currentVersion === manifest.version) {
+      console.log(chalk.gray(`  ${packName}@${manifest.version} already installed, skipping`));
+      continue;
+    }
+
+    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, packName, manifest.version, targets);
+    installedCount++;
+
+    console.log(
+      chalk.green(`  + ${packName}@${manifest.version}`) +
+        chalk.gray(` (${totalFiles} rules)`)
+    );
+  }
+
+  await saveTracker(projectDir, tracker);
+
+  if (installedCount === 0) {
+    console.log(chalk.yellow('\nAll packs already up to date.'));
+  } else {
+    console.log(chalk.green(`\nInstalled ${installedCount} pack(s) for ${targets.join(', ')}.`));
+  }
+}

package/src/commands/list.js

@@ -0,0 +1,54 @@
+import chalk from 'chalk';
+import { listAvailablePacks } from '../core/manifest.js';
+import { loadTracker } from '../core/tracker.js';
+
+export async function listCommand(options) {
+  if (options.installed) {
+    await listInstalled();
+  } else {
+    await listAvailable();
+  }
+}
+
+async function listAvailable() {
+  const packs = await listAvailablePacks();
+
+  if (packs.length === 0) {
+    console.log(chalk.yellow('No packs available.'));
+    return;
+  }
+
+  console.log(chalk.bold('\nAvailable packs:\n'));
+
+  for (const pack of packs) {
+    const deps = pack.depends.length > 0 ? chalk.gray(` (requires: ${pack.depends.join(', ')})`) : '';
+    console.log(`  ${chalk.cyan(pack.name)}@${pack.version}${deps}`);
+    if (pack.description) {
+      console.log(`    ${chalk.gray(pack.description)}`);
+    }
+  }
+
+  console.log('');
+}
+
+async function listInstalled() {
+  const projectDir = process.cwd();
+  const tracker = await loadTracker(projectDir);
+  const installed = Object.entries(tracker.installed);
+
+  if (installed.length === 0) {
+    console.log(chalk.yellow('No packs installed in this project.'));
+    return;
+  }
+
+  console.log(chalk.bold('\nInstalled packs:\n'));
+
+  for (const [name, info] of installed) {
+    const date = new Date(info.installedAt).toLocaleDateString();
+    const targets = info.targets.join(', ');
+    console.log(`  ${chalk.cyan(name)}@${info.version}`);
+    console.log(`    ${chalk.gray(`installed: ${date} | targets: ${targets}`)}`);
+  }
+
+  console.log('');
+}