claude-skill-lord 1.5.0

package/scripts/install.js

@@ -0,0 +1,144 @@
+#!/usr/bin/env node
+
+/**
+ * SkillLord Installer — Profile-aware selective installation
+ *
+ * Usage:
+ *   skilllord-install [profile] [--target <path>] [--dry-run]
+ *
+ * Profiles: core, developer, full (default: developer)
+ *
+ * Examples:
+ *   skilllord-install core
+ *   skilllord-install full --target ./my-project
+ *   skilllord-install developer --dry-run
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+// Parse CLI args
+const args = process.argv.slice(2);
+const flags = {};
+let profile = 'developer';
+
+for (let i = 0; i < args.length; i++) {
+  if (args[i] === '--target' && args[i + 1]) {
+    flags.target = args[++i];
+  } else if (args[i] === '--dry-run') {
+    flags.dryRun = true;
+  } else if (args[i] === '--help' || args[i] === '-h') {
+    flags.help = true;
+  } else if (!args[i].startsWith('-')) {
+    profile = args[i];
+  }
+}
+
+if (flags.help) {
+  console.log(`
+Claude Skill Lord Installer — Profile-aware selective installation
+
+Usage: csl init [profile] [options]
+
+Profiles:
+  core        16 tier-1 skills, 7 agents (lightweight)
+  developer   44 skills (tier-1+2), 22 agents (recommended)
+  full        61 skills (all tiers), 22 agents (everything)
+
+Options:
+  --target <path>  Target project directory (default: current directory)
+  --dry-run        Show what would be installed without copying
+  --help, -h       Show this help
+  `);
+  process.exit(0);
+}
+
+// Resolve paths
+const skillLordRoot = path.resolve(__dirname, '..');
+const targetDir = path.resolve(flags.target || process.cwd());
+const targetClaudeDir = path.join(targetDir, '.claude');
+
+// Load manifests
+const profilesPath = path.join(skillLordRoot, 'manifests', 'install-profiles.json');
+const modulesPath = path.join(skillLordRoot, 'manifests', 'install-modules.json');
+
+if (!fs.existsSync(profilesPath) || !fs.existsSync(modulesPath)) {
+  console.error('Error: Manifest files not found. Ensure SkillLord is properly installed.');
+  process.exit(1);
+}
+
+const profiles = JSON.parse(fs.readFileSync(profilesPath, 'utf8'));
+const modules = JSON.parse(fs.readFileSync(modulesPath, 'utf8'));
+
+const selectedProfile = profiles.profiles[profile];
+if (!selectedProfile) {
+  console.error(`Error: Unknown profile "${profile}".`);
+  console.error(`Available profiles: ${Object.keys(profiles.profiles).join(', ')}`);
+  process.exit(1);
+}
+
+const pkg = require(path.join(skillLordRoot, 'package.json'));
+console.log(`\n  Claude Skill Lord Installer v${pkg.version}`);
+console.log(`  ${'='.repeat(38)}\n`);
+console.log(`  Profile:  ${profile}`);
+console.log(`  Desc:     ${selectedProfile.description}`);
+console.log(`  Target:   ${targetDir}`);
+console.log(`  Dry run:  ${flags.dryRun ? 'yes' : 'no'}\n`);
+
+// Resolve modules for selected profile
+const { collectModuleFiles } = require('./lib/profile-utils');
+const selectedModules = modules.modules.filter(
+  (m) => selectedProfile.modules.includes(m.id)
+);
+
+// Collect all files to copy
+for (const mod of selectedModules) {
+  console.log(`  [${mod.cost}] ${mod.id}: ${mod.description}`);
+}
+const filesToCopy = collectModuleFiles(selectedModules);
+
+console.log(`\n  Files to install: ${filesToCopy.length}`);
+
+if (flags.dryRun) {
+  console.log('\n  [DRY RUN] Files that would be copied:\n');
+  for (const f of filesToCopy) {
+    console.log(`    ${f.rel}`);
+  }
+  console.log(`\n  Total: ${filesToCopy.length} files`);
+  process.exit(0);
+}
+
+// Copy files
+let copied = 0;
+let skipped = 0;
+
+for (const f of filesToCopy) {
+  const destPath = path.join(targetClaudeDir, f.rel);
+  const destDir = path.dirname(destPath);
+
+  // Create directory if needed
+  if (!fs.existsSync(destDir)) {
+    fs.mkdirSync(destDir, { recursive: true });
+  }
+
+  // Copy file (don't overwrite existing)
+  if (fs.existsSync(destPath)) {
+    skipped++;
+  } else {
+    fs.copyFileSync(f.src, destPath);
+    copied++;
+  }
+}
+
+// Generate plugin.json for the target project (always regenerate to match current profile)
+const { buildPluginJson } = require('./lib/profile-utils');
+const pluginJsonPath = path.join(targetClaudeDir, 'plugin.json');
+const pluginJson = buildPluginJson(profile, filesToCopy, pkg.version);
+fs.writeFileSync(pluginJsonPath, JSON.stringify(pluginJson, null, 2));
+console.log(`\n  Generated: .claude/plugin.json`);
+
+console.log(`\n  Installation complete!`);
+console.log(`  Copied:  ${copied} files`);
+console.log(`  Skipped: ${skipped} files (already exist)`);
+console.log(`\n  Run "claude" in your project to start using Claude Skill Lord.\n`);
+

package/scripts/lib/hook-flags.js

@@ -0,0 +1,74 @@
+#!/usr/bin/env node
+/**
+ * Shared hook enable/disable controls.
+ *
+ * Controls:
+ * - ECC_HOOK_PROFILE=minimal|standard|strict (default: standard)
+ * - ECC_DISABLED_HOOKS=comma,separated,hook,ids
+ */
+
+'use strict';
+
+const VALID_PROFILES = new Set(['minimal', 'standard', 'strict']);
+
+function normalizeId(value) {
+  return String(value || '').trim().toLowerCase();
+}
+
+function getHookProfile() {
+  const raw = String(process.env.ECC_HOOK_PROFILE || 'standard').trim().toLowerCase();
+  return VALID_PROFILES.has(raw) ? raw : 'standard';
+}
+
+function getDisabledHookIds() {
+  const raw = String(process.env.ECC_DISABLED_HOOKS || '');
+  if (!raw.trim()) return new Set();
+
+  return new Set(
+    raw
+      .split(',')
+      .map(v => normalizeId(v))
+      .filter(Boolean)
+  );
+}
+
+function parseProfiles(rawProfiles, fallback = ['standard', 'strict']) {
+  if (!rawProfiles) return [...fallback];
+
+  if (Array.isArray(rawProfiles)) {
+    const parsed = rawProfiles
+      .map(v => String(v || '').trim().toLowerCase())
+      .filter(v => VALID_PROFILES.has(v));
+    return parsed.length > 0 ? parsed : [...fallback];
+  }
+
+  const parsed = String(rawProfiles)
+    .split(',')
+    .map(v => v.trim().toLowerCase())
+    .filter(v => VALID_PROFILES.has(v));
+
+  return parsed.length > 0 ? parsed : [...fallback];
+}
+
+function isHookEnabled(hookId, options = {}) {
+  const id = normalizeId(hookId);
+  if (!id) return true;
+
+  const disabled = getDisabledHookIds();
+  if (disabled.has(id)) {
+    return false;
+  }
+
+  const profile = getHookProfile();
+  const allowedProfiles = parseProfiles(options.profiles);
+  return allowedProfiles.includes(profile);
+}
+
+module.exports = {
+  VALID_PROFILES,
+  normalizeId,
+  getHookProfile,
+  getDisabledHookIds,
+  parseProfiles,
+  isHookEnabled,
+};

package/scripts/lib/profile-utils.js

@@ -0,0 +1,97 @@
+/**
+ * Shared utilities for profile detection and plugin.json generation.
+ * Used by: install.js, sl.js (migrate, upgrade, doctor, list, diff)
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+const rootDir = path.resolve(__dirname, '..', '..');
+
+function loadManifests() {
+  const profiles = JSON.parse(fs.readFileSync(path.join(rootDir, 'manifests', 'install-profiles.json'), 'utf8'));
+  const modules = JSON.parse(fs.readFileSync(path.join(rootDir, 'manifests', 'install-modules.json'), 'utf8'));
+  return { profiles, modules };
+}
+
+function detectInstalledProfile(claudeDir) {
+  const skillsDir = path.join(claudeDir, 'skills');
+  if (!fs.existsSync(skillsDir)) return null;
+  const dirs = fs.readdirSync(skillsDir, { withFileTypes: true })
+    .filter(e => e.isDirectory()).map(e => e.name);
+  if (dirs.includes('tier-3')) return 'full';
+  if (dirs.includes('tier-2')) return 'developer';
+  return 'core';
+}
+
+function buildPluginJson(profile, filesToCopy, version) {
+  const agentFiles = filesToCopy
+    .filter(f => f.rel.startsWith('agents/') && f.rel.endsWith('.md'))
+    .map(f => `./${f.rel}`);
+
+  const skillDirs = new Set();
+  filesToCopy
+    .filter(f => f.rel.startsWith('skills/'))
+    .forEach(f => {
+      const parts = f.rel.split('/');
+      if (parts.length >= 2) skillDirs.add(`./${parts[0]}/${parts[1]}/`);
+    });
+
+  return {
+    name: 'claude-skill-lord',
+    version,
+    profile,
+    description: `Claude Skill Lord (${profile} profile)`,
+    agents: agentFiles,
+    commands: ['./commands/'],
+    skills: [...skillDirs],
+  };
+}
+
+function readPluginJson(claudeDir) {
+  const p = path.join(claudeDir, 'plugin.json');
+  if (!fs.existsSync(p)) return null;
+  try { return JSON.parse(fs.readFileSync(p, 'utf8')); }
+  catch { return null; }
+}
+
+function collectFiles(dirPath, relBase, results) {
+  const entries = fs.readdirSync(dirPath, { withFileTypes: true });
+  for (const entry of entries) {
+    const fullPath = path.join(dirPath, entry.name);
+    const relPath = path.join(relBase, entry.name);
+    if (entry.isDirectory()) collectFiles(fullPath, relPath, results);
+    else results.push({ src: fullPath, rel: relPath });
+  }
+}
+
+function collectModuleFiles(selectedModules) {
+  const filesToCopy = [];
+  for (const mod of selectedModules) {
+    for (const srcRelPath of mod.paths) {
+      const srcFullPath = path.join(rootDir, srcRelPath);
+      if (!fs.existsSync(srcFullPath)) continue;
+      const stat = fs.statSync(srcFullPath);
+      if (stat.isDirectory()) {
+        const collected = [];
+        collectFiles(srcFullPath, srcRelPath, collected);
+        if (mod.destPrefix) {
+          collected.forEach(f => {
+            const relToSrc = path.relative(
+              path.resolve(rootDir, srcRelPath),
+              path.resolve(rootDir, f.rel)
+            );
+            f.rel = path.join(mod.destPrefix, path.basename(srcRelPath), relToSrc);
+          });
+        }
+        filesToCopy.push(...collected);
+      } else {
+        const rel = mod.destPrefix ? path.join(mod.destPrefix, srcRelPath) : srcRelPath;
+        filesToCopy.push({ src: srcFullPath, rel });
+      }
+    }
+  }
+  return filesToCopy;
+}
+
+module.exports = { loadManifests, detectInstalledProfile, buildPluginJson, readPluginJson, collectFiles, collectModuleFiles };

package/scripts/lib/resolve-formatter.js

@@ -0,0 +1,185 @@
+/**
+ * Shared formatter resolution utilities with caching.
+ *
+ * Extracts project-root discovery, formatter detection, and binary
+ * resolution into a single module so that post-edit-format.js and
+ * quality-gate.js avoid duplicating work and filesystem lookups.
+ */
+
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+
+// ── Caches (per-process, cleared on next hook invocation) ───────────
+const projectRootCache = new Map();
+const formatterCache = new Map();
+const binCache = new Map();
+
+// ── Config file lists (single source of truth) ─────────────────────
+
+const BIOME_CONFIGS = ['biome.json', 'biome.jsonc'];
+
+const PRETTIER_CONFIGS = [
+  '.prettierrc',
+  '.prettierrc.json',
+  '.prettierrc.js',
+  '.prettierrc.cjs',
+  '.prettierrc.mjs',
+  '.prettierrc.yml',
+  '.prettierrc.yaml',
+  '.prettierrc.toml',
+  'prettier.config.js',
+  'prettier.config.cjs',
+  'prettier.config.mjs'
+];
+
+const PROJECT_ROOT_MARKERS = ['package.json', ...BIOME_CONFIGS, ...PRETTIER_CONFIGS];
+
+// ── Windows .cmd shim mapping ───────────────────────────────────────
+const WIN_CMD_SHIMS = { npx: 'npx.cmd', pnpm: 'pnpm.cmd', yarn: 'yarn.cmd', bunx: 'bunx.cmd' };
+
+// ── Formatter → package name mapping ────────────────────────────────
+const FORMATTER_PACKAGES = {
+  biome: { binName: 'biome', pkgName: '@biomejs/biome' },
+  prettier: { binName: 'prettier', pkgName: 'prettier' }
+};
+
+// ── Public helpers ──────────────────────────────────────────────────
+
+/**
+ * Walk up from `startDir` until a directory containing a known project
+ * root marker (package.json or formatter config) is found.
+ * Returns `startDir` as fallback when no marker exists above it.
+ *
+ * @param {string} startDir - Absolute directory path to start from
+ * @returns {string} Absolute path to the project root
+ */
+function findProjectRoot(startDir) {
+  if (projectRootCache.has(startDir)) return projectRootCache.get(startDir);
+
+  let dir = startDir;
+  while (dir !== path.dirname(dir)) {
+    for (const marker of PROJECT_ROOT_MARKERS) {
+      if (fs.existsSync(path.join(dir, marker))) {
+        projectRootCache.set(startDir, dir);
+        return dir;
+      }
+    }
+    dir = path.dirname(dir);
+  }
+
+  projectRootCache.set(startDir, startDir);
+  return startDir;
+}
+
+/**
+ * Detect the formatter configured in the project.
+ * Biome takes priority over Prettier.
+ *
+ * @param {string} projectRoot - Absolute path to the project root
+ * @returns {'biome' | 'prettier' | null}
+ */
+function detectFormatter(projectRoot) {
+  if (formatterCache.has(projectRoot)) return formatterCache.get(projectRoot);
+
+  for (const cfg of BIOME_CONFIGS) {
+    if (fs.existsSync(path.join(projectRoot, cfg))) {
+      formatterCache.set(projectRoot, 'biome');
+      return 'biome';
+    }
+  }
+
+  // Check package.json "prettier" key before config files
+  try {
+    const pkgPath = path.join(projectRoot, 'package.json');
+    if (fs.existsSync(pkgPath)) {
+      const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf8'));
+      if ('prettier' in pkg) {
+        formatterCache.set(projectRoot, 'prettier');
+        return 'prettier';
+      }
+    }
+  } catch {
+    // Malformed package.json — continue to file-based detection
+  }
+
+  for (const cfg of PRETTIER_CONFIGS) {
+    if (fs.existsSync(path.join(projectRoot, cfg))) {
+      formatterCache.set(projectRoot, 'prettier');
+      return 'prettier';
+    }
+  }
+
+  formatterCache.set(projectRoot, null);
+  return null;
+}
+
+/**
+ * Resolve the runner binary and prefix args for the configured package
+ * manager (respects CLAUDE_PACKAGE_MANAGER env and project config).
+ *
+ * @param {string} projectRoot - Absolute path to the project root
+ * @returns {{ bin: string, prefix: string[] }}
+ */
+function getRunnerFromPackageManager(projectRoot) {
+  const isWin = process.platform === 'win32';
+  const { getPackageManager } = require('./package-manager');
+  const pm = getPackageManager({ projectDir: projectRoot });
+  const execCmd = pm?.config?.execCmd || 'npx';
+  const [rawBin = 'npx', ...prefix] = execCmd.split(/\s+/).filter(Boolean);
+  const bin = isWin ? WIN_CMD_SHIMS[rawBin] || rawBin : rawBin;
+  return { bin, prefix };
+}
+
+/**
+ * Resolve the formatter binary, preferring the local node_modules/.bin
+ * installation over the package manager exec command to avoid
+ * package-resolution overhead.
+ *
+ * @param {string} projectRoot - Absolute path to the project root
+ * @param {'biome' | 'prettier'} formatter - Detected formatter name
+ * @returns {{ bin: string, prefix: string[] } | null}
+ *   `bin`    – executable path (absolute local path or runner binary)
+ *   `prefix` – extra args to prepend (e.g. ['@biomejs/biome'] when using npx)
+ */
+function resolveFormatterBin(projectRoot, formatter) {
+  const cacheKey = `${projectRoot}:${formatter}`;
+  if (binCache.has(cacheKey)) return binCache.get(cacheKey);
+
+  const pkg = FORMATTER_PACKAGES[formatter];
+  if (!pkg) {
+    binCache.set(cacheKey, null);
+    return null;
+  }
+
+  const isWin = process.platform === 'win32';
+  const localBin = path.join(projectRoot, 'node_modules', '.bin', isWin ? `${pkg.binName}.cmd` : pkg.binName);
+
+  if (fs.existsSync(localBin)) {
+    const result = { bin: localBin, prefix: [] };
+    binCache.set(cacheKey, result);
+    return result;
+  }
+
+  const runner = getRunnerFromPackageManager(projectRoot);
+  const result = { bin: runner.bin, prefix: [...runner.prefix, pkg.pkgName] };
+  binCache.set(cacheKey, result);
+  return result;
+}
+
+/**
+ * Clear all caches. Useful for testing.
+ */
+function clearCaches() {
+  projectRootCache.clear();
+  formatterCache.clear();
+  binCache.clear();
+}
+
+module.exports = {
+  findProjectRoot,
+  detectFormatter,
+  resolveFormatterBin,
+  clearCaches
+};

package/scripts/lib/resolve-root.js

@@ -0,0 +1,89 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+/**
+ * Resolve the SkillLord plugin root directory.
+ *
+ * Tries, in order:
+ *   1. CLAUDE_PLUGIN_ROOT env var (set by Claude Code for hooks, or by user)
+ *   2. Standard install location (~/.claude/) — when scripts exist there
+ *   3. Plugin cache auto-detection — scans ~/.claude/plugins/cache/skilllord/
+ *   4. Fallback to ~/.claude/ (original behaviour)
+ *
+ * @param {object} [options]
+ * @param {string} [options.homeDir]  Override home directory (for testing)
+ * @param {string} [options.envRoot]  Override CLAUDE_PLUGIN_ROOT (for testing)
+ * @param {string} [options.probe]    Relative path used to verify a candidate root
+ *                                    contains plugin scripts. Default: 'scripts/lib/utils.js'
+ * @returns {string} Resolved plugin root path
+ */
+function resolveRoot(options = {}) {
+  const envRoot = options.envRoot !== undefined
+    ? options.envRoot
+    : (process.env.CLAUDE_PLUGIN_ROOT || '');
+
+  if (envRoot && envRoot.trim()) {
+    return envRoot.trim();
+  }
+
+  const homeDir = options.homeDir || os.homedir();
+  const claudeDir = path.join(homeDir, '.claude');
+  const probe = options.probe || path.join('scripts', 'lib', 'utils.js');
+
+  // Standard install — files are copied directly into ~/.claude/
+  if (fs.existsSync(path.join(claudeDir, probe))) {
+    return claudeDir;
+  }
+
+  // Plugin cache — Claude Code stores marketplace plugins under
+  // ~/.claude/plugins/cache/<plugin-name>/<org>/<version>/
+  try {
+    const cacheBase = path.join(claudeDir, 'plugins', 'cache', 'skilllord');
+    const orgDirs = fs.readdirSync(cacheBase, { withFileTypes: true });
+
+    for (const orgEntry of orgDirs) {
+      if (!orgEntry.isDirectory()) continue;
+      const orgPath = path.join(cacheBase, orgEntry.name);
+
+      let versionDirs;
+      try {
+        versionDirs = fs.readdirSync(orgPath, { withFileTypes: true });
+      } catch {
+        continue;
+      }
+
+      for (const verEntry of versionDirs) {
+        if (!verEntry.isDirectory()) continue;
+        const candidate = path.join(orgPath, verEntry.name);
+        if (fs.existsSync(path.join(candidate, probe))) {
+          return candidate;
+        }
+      }
+    }
+  } catch {
+    // Plugin cache doesn't exist or isn't readable — continue to fallback
+  }
+
+  return claudeDir;
+}
+
+/**
+ * Compact inline version for embedding in command .md code blocks.
+ *
+ * This is the minified form of resolveRoot() suitable for use in
+ * node -e "..." scripts where require() is not available before the
+ * root is known.
+ *
+ * Usage in commands:
+ *   const _r = <paste INLINE_RESOLVE>;
+ *   const sm = require(_r + '/scripts/lib/session-manager');
+ */
+const INLINE_RESOLVE = `(()=>{var e=process.env.CLAUDE_PLUGIN_ROOT;if(e&&e.trim())return e.trim();var p=require('path'),f=require('fs'),h=require('os').homedir(),d=p.join(h,'.claude'),q=p.join('scripts','lib','utils.js');if(f.existsSync(p.join(d,q)))return d;try{var b=p.join(d,'plugins','cache','skilllord');for(var o of f.readdirSync(b))for(var v of f.readdirSync(p.join(b,o))){var c=p.join(b,o,v);if(f.existsSync(p.join(c,q)))return c}}catch(x){}return d})()`;
+
+module.exports = {
+  resolveRoot,
+  INLINE_RESOLVE,
+};