harveyz-skill 0.6.2 → 0.7.0

package/hooks/check-similar-branch/check-similar-branch.sh

@@ -0,0 +1,75 @@
+#!/bin/bash
+# check-similar-branch.sh
+# version: 1.0.0
+# PreToolUse command hook: 用 LLM 语义分析检测相似分支
+# 触发条件: git checkout -b 或 git switch -c
+
+set -euo pipefail
+
+INPUT=$(cat)
+CMD=$(echo "$INPUT" | jq -r '.tool_input.command // ""')
+
+# 只拦截分支创建命令
+if ! echo "$CMD" | grep -qE 'git (checkout -b|switch -c)'; then
+  exit 0
+fi
+
+# 提取新分支名
+NEW_BRANCH=$(echo "$CMD" | grep -oE '(checkout -b|switch -c)\s+\S+' | awk '{print $NF}' | tr -d "'\"")
+[ -z "$NEW_BRANCH" ] && exit 0
+
+# 确保在 git 仓库中
+GIT_ROOT=$(git rev-parse --show-toplevel 2>/dev/null) || exit 0
+
+# 获取现有分支列表（排除新分支本身和 HEAD）
+BRANCHES=$(git -C "$GIT_ROOT" branch 2>/dev/null \
+  | sed 's|[ *]*||' \
+  | grep -v "^${NEW_BRANCH}$" \
+  | grep -v 'HEAD' \
+  || true)
+
+[ -z "$BRANCHES" ] && exit 0
+
+# 用 claude -p 做语义相似度分析
+BRANCH_LIST=$(echo "$BRANCHES" | head -40)  # 最多传 40 条，避免 token 过多
+
+LLM_RESULT=$(claude -p "You are a git branch similarity checker. Determine if the new branch semantically overlaps with any existing branches.
+
+New branch: $NEW_BRANCH
+
+Existing branches:
+$BRANCH_LIST
+
+Rules:
+- SIMILAR: same type prefix (feature/, fix/, etc.) AND same feature/module/topic (even if worded differently)
+- NOT similar: different type prefix, or completely unrelated topics
+- Ignore generic words: add, update, fix, improve, cleanup
+
+Respond with ONLY valid JSON, no explanation:
+- If similar branches found: {\"similar\": true, \"matches\": [\"branch-name-1\", \"branch-name-2\"]}
+- If none found: {\"similar\": false}" 2>/dev/null)
+
+# 解析 LLM 结果
+IS_SIMILAR=$(echo "$LLM_RESULT" | jq -r '.similar // false' 2>/dev/null || echo "false")
+
+if [ "$IS_SIMILAR" = "true" ]; then
+  # 格式化相似分支列表
+  MATCH_LIST=$(echo "$LLM_RESULT" | jq -r '.matches[]' 2>/dev/null | sed 's/^/  • /' | tr '\n' '|' | sed 's/|$//' | tr '|' '\n')
+
+  MSG="⚠️ BRANCH_GUARD: 发现语义相似的已有分支，建议复用而非新建。
+
+新分支: $NEW_BRANCH
+相似分支:
+$MATCH_LIST
+
+请询问用户：是否复用已有分支？
+若选择复用，将同步 staging 最新代码：
+  git checkout <branch>
+  git fetch origin
+  git merge origin/staging"
+
+  jq -n --arg msg "$MSG" \
+    '{"hookSpecificOutput":{"hookEventName":"PreToolUse","permissionDecision":"allow","additionalContext":$msg}}'
+fi
+
+exit 0

package/lib/bundles.js

@@ -3,11 +3,12 @@ import os from 'os'
 import { createRequire } from 'module'
 import path from 'path'
 import { fileURLToPath } from 'url'
+import { USER_ONLY_TARGETS } from './targets.js'
 
 const require = createRequire(import.meta.url)
 const __dirname = path.dirname(fileURLToPath(import.meta.url))
 
-const { bundleMeta, skills: skillDefs, toolBundleMeta = {}, tools: toolDefs = [] } = require('../skills-index.json')
+const { bundleMeta, skills: skillDefs, toolBundleMeta = {}, tools: toolDefs = [], hooks: hookDefs = [] } = require('../skills-index.json')
 const repoRoot = path.join(__dirname, '..')
 const skillsRoot = path.join(repoRoot, 'skills')
 
@@ -49,7 +50,8 @@ export function resolveSkillsByName(names) {
   return names.map(name => {
     const skill = skillDefs.find(s => s.path.split('/').pop() === name)
     if (!skill) throw new Error(`Unknown skill: "${name}"`)
-    return { skillName: name, srcPath: path.join(skillsRoot, skill.path) }
+    const srcPath = path.join(skillsRoot, skill.path)
+    return { skillName: name, srcPath, version: readVersion(srcPath) }
   })
 }
 
@@ -65,7 +67,8 @@ export function resolveSkills(selectedBundles) {
       if (seen.has(skill.path)) continue
       seen.add(skill.path)
       const skillName = skill.path.split('/').pop()
-      result.push({ skillName, srcPath: path.join(skillsRoot, skill.path) })
+      const srcPath   = path.join(skillsRoot, skill.path)
+      result.push({ skillName, srcPath, version: readVersion(srcPath) })
     }
   }
   return result
@@ -129,12 +132,14 @@ export function getAllToolItems() {
 // 每个工具: { version: string, status: 'up-to-date'|'update'|'none' }
 export function checkInstalled(skillName, availableVersion) {
   const home = os.homedir()
-  const targets = ['claude', 'cursor', 'codex']
+  const targets = ['claude', 'cursor', 'codex', 'openclaw', 'hermes']
 
   function checkScope(dirFn) {
     const result = {}
     for (const t of targets) {
-      const skillPath = path.join(dirFn(t), skillName)
+      const dir = dirFn(t)
+      if (dir === null) { result[t] = { version: '—', status: 'none' }; continue }
+      const skillPath = path.join(dir, skillName)
       const version = readVersion(skillPath)
       const status = version === '—' ? 'none'
         : version === availableVersion ? 'up-to-date'
@@ -149,7 +154,9 @@ export function checkInstalled(skillName, availableVersion) {
 
   return {
     user:    checkScope(t => path.join(home, `.${t}`, 'skills')),
-    project: cwd === home ? noneScope : checkScope(t => path.join(cwd, `.${t}`, 'skills')),
+    project: cwd === home ? noneScope : checkScope(t =>
+      USER_ONLY_TARGETS.has(t) ? null : path.join(cwd, `.${t}`, 'skills')
+    ),
   }
 }
 
@@ -161,7 +168,67 @@ export function scopeSummary(scopeDetail) {
   return 'none'
 }
 
-export { formatChoice, readVersion }
+// ── Hooks ────────────────────────────────────────────────────────────────────
+
+function readHookVersion(scriptPath) {
+  try {
+    const content = fs.readFileSync(scriptPath, 'utf-8')
+    const m = content.match(/^#\s*version:\s*(.+)$/m)
+    return m ? m[1].trim() : '—'
+  } catch { return '—' }
+}
+
+export function getAllHookItems() {
+  return hookDefs.map(hook => {
+    const srcPath = path.join(repoRoot, hook.path, `${hook.name}.sh`)
+    return {
+      ...hook,
+      srcPath,
+      version: readHookVersion(srcPath),
+    }
+  })
+}
+
+export function checkHookInstalled(hookName) {
+  const home = os.homedir()
+  const cwd  = process.cwd()
+
+  function checkScope(hooksDir, settingsPath) {
+    const scriptPath   = path.join(hooksDir, `${hookName}.sh`)
+    const scriptExists = fs.existsSync(scriptPath)
+    const installedVersion = scriptExists ? readHookVersion(scriptPath) : '—'
+    let registered = false
+    try {
+      const settings = JSON.parse(fs.readFileSync(settingsPath, 'utf-8'))
+      registered = Object.values(settings.hooks ?? {}).some(entries =>
+        Array.isArray(entries) && entries.some(e =>
+          Array.isArray(e.hooks) && e.hooks.some(h =>
+            typeof h.command === 'string' && h.command.includes(`${hookName}.sh`)
+          )
+        )
+      )
+    } catch { /* settings.json 不存在或解析失败 */ }
+
+    const status = scriptExists && registered ? 'installed'
+                 : scriptExists || registered ? 'partial'
+                 : 'none'
+    return { status, version: installedVersion }
+  }
+
+  const userHooksDir    = path.join(home, '.claude', 'hooks')
+  const userSettings    = path.join(home, '.claude', 'settings.json')
+  const projectHooksDir = path.join(cwd,  '.claude', 'hooks')
+  const projectSettings = path.join(cwd,  '.claude', 'settings.json')
+
+  return {
+    user:    checkScope(userHooksDir, userSettings),
+    project: cwd === home
+      ? { status: 'none', version: '—' }
+      : checkScope(projectHooksDir, projectSettings),
+  }
+}
+
+export { formatChoice, readVersion, readHookVersion }
 
 const HSKILL_TOOLS_DATA = path.join(os.homedir(), '.local', 'share', 'hskill', 'tools')
 

package/lib/installer.js

@@ -4,6 +4,7 @@ import path from 'path'
 import { confirm } from '@inquirer/prompts'
 import chalk from 'chalk'
 import { loadVarDefs, buildAutoVars, resolveVars, substituteVars } from './vars.js'
+import { readVersion, readHookVersion } from './bundles.js'
 
 const BINARY_EXTS = new Set(['.db', '.pyc', '.jpg', '.jpeg', '.png', '.gif', '.webp', '.pdf'])
 const SKIP_NAMES  = new Set(['vars.json', '__pycache__', '.DS_Store'])
@@ -32,25 +33,35 @@ async function copyDir(srcDir, destDir, varsMap) {
 export async function installTools(tools, targetDir, force = false) {
   const exists = await fs.pathExists(targetDir)
   if (!exists) {
-    console.log(chalk.dim(`  · Creating directory: ${targetDir}`))
+    console.error(chalk.dim(`  · Creating directory: ${targetDir}`))
     await fs.ensureDir(targetDir)
   }
 
   const installed = []
+  const skipped   = []
+  const failed    = []
+
   for (const { toolName, srcPath } of tools) {
     const scriptSrc = path.join(srcPath, `${toolName}.sh`)
     const destPath  = path.join(targetDir, toolName)
 
     if (!await fs.pathExists(scriptSrc)) {
-      console.log(chalk.red(`  ✗ Script not found: ${scriptSrc}`))
+      console.error(chalk.red(`  ✗ Script not found: ${scriptSrc}`))
+      failed.push({ name: toolName, reason: 'source_not_found' })
       continue
     }
 
     const destExists = await fs.pathExists(destPath)
     if (destExists && !force) {
+      if (!process.stdout.isTTY) {
+        skipped.push({ name: toolName, reason: 'already_exists' })
+        console.error(chalk.dim(`  · Skipped ${toolName} (already exists — use --force to overwrite)`))
+        continue
+      }
       const ok = await confirm({ message: `${destPath} already exists. Overwrite?`, default: true })
       if (!ok) {
-        console.log(chalk.dim(`  · Skipped ${toolName}`))
+        skipped.push({ name: toolName, reason: 'already_exists' })
+        console.error(chalk.dim(`  · Skipped ${toolName}`))
         continue
       }
     }
@@ -59,11 +70,20 @@ export async function installTools(tools, targetDir, force = false) {
       const varDefs = await loadVarDefs(srcPath)
       let varsMap = {}
       if (varDefs.length > 0) {
-        console.log(chalk.bold(`\n  Configure ${toolName}:`))
-        varsMap = await resolveVars(varDefs, buildAutoVars())
-        for (const def of varDefs) {
-          if (def.configFile && def.configKey) {
-            await _writeToolConfigVar(def, varsMap[def.name])
+        if (!process.stdout.isTTY) {
+          const autoVars = buildAutoVars()
+          for (const def of varDefs) {
+            autoVars[def.name] = substituteVars(def.default ?? '', autoVars)
+          }
+          varsMap = autoVars
+          console.error(chalk.dim(`  · ${toolName}: using default vars (non-TTY)`))
+        } else {
+          console.error(chalk.bold(`\n  Configure ${toolName}:`))
+          varsMap = await resolveVars(varDefs, buildAutoVars())
+          for (const def of varDefs) {
+            if (def.configFile && def.configKey) {
+              await _writeToolConfigVar(def, varsMap[def.name])
+            }
           }
         }
       }
@@ -80,18 +100,19 @@ export async function installTools(tools, targetDir, force = false) {
       installed.push(toolName)
       await _patchZshrc(srcPath, toolName)
     } catch (err) {
-      console.log(chalk.red(`  ✗ Failed to install ${toolName}: ${err.message}`))
+      console.error(chalk.red(`  ✗ Failed to install ${toolName}: ${err.message}`))
+      failed.push({ name: toolName, reason: 'copy_failed', detail: err.message })
     }
   }
 
-  return installed
+  return { installed, skipped, failed }
 }
 
 async function _writeToolConfigVar(def, value) {
   const configPath = def.configFile.replace(/^~/, os.homedir())
   await fs.ensureDir(path.dirname(configPath))
   await fs.writeFile(configPath, `${def.configKey}=("${value}")\n`, 'utf-8')
-  console.log(chalk.green(`  ✓ Config written to ${def.configFile}`))
+  console.error(chalk.green(`  ✓ Config written to ${def.configFile}`))
 }
 
 async function _patchZshrc(srcPath, toolName) {
@@ -106,7 +127,12 @@ async function _patchZshrc(srcPath, toolName) {
     : ''
 
   if (existing.includes(marker)) {
-    console.log(chalk.dim(`  · ~/.zshrc already has ${toolName} config, skipping`))
+    console.error(chalk.dim(`  · ~/.zshrc already has ${toolName} config, skipping`))
+    return
+  }
+
+  if (!process.stdout.isTTY) {
+    console.error(chalk.dim(`  · Skipped ~/.zshrc patch for ${toolName} (non-TTY — add manually)`))
     return
   }
 
@@ -118,7 +144,7 @@ async function _patchZshrc(srcPath, toolName) {
 
   const snippet = await fs.readFile(snippetPath, 'utf-8')
   await fs.appendFile(zshrcPath, snippet, 'utf-8')
-  console.log(chalk.green(`  ✓ Written to ~/.zshrc`))
+  console.error(chalk.green(`  ✓ Written to ~/.zshrc`))
 }
 
 // skills: [{ skillName, srcPath }]
@@ -130,46 +156,246 @@ export async function installSkills(skills, targets, force = false) {
   for (const { name: targetName, dir: targetDir } of targets) {
     const exists = await fs.pathExists(targetDir)
     if (!exists) {
-      console.log(chalk.dim(`  · Skipping ${targetName} (directory not found: ${targetDir})`))
-      continue
+      console.error(chalk.dim(`  · Creating directory: ${targetDir}`))
+      await fs.ensureDir(targetDir)
     }
 
     const installed = []
-    for (const { skillName, srcPath } of skills) {
-      const destPath = path.join(targetDir, skillName)
+    const skipped   = []
+    const failed    = []
+
+    for (const { skillName, srcPath, version: availableVersion } of skills) {
+      if (!await fs.pathExists(srcPath)) {
+        console.error(chalk.red(`  ✗ Source not found: ${srcPath}`))
+        failed.push({ name: skillName, reason: 'source_not_found' })
+        continue
+      }
+
+      const destPath   = path.join(targetDir, skillName)
       const destExists = await fs.pathExists(destPath)
 
       if (destExists && !force) {
-        const ok = await confirm({ message: `${targetName}/${skillName} already exists. Overwrite?`, default: false })
-        if (!ok) {
-          console.log(chalk.dim(`  · Skipped ${targetName}/${skillName}`))
+        const installedVersion = readVersion(destPath)
+        if (availableVersion && installedVersion === availableVersion) {
+          skipped.push({ name: skillName, reason: 'up-to-date', version: installedVersion })
+          console.error(chalk.dim(`  · Skipped ${skillName} (up-to-date ${installedVersion})`))
           continue
         }
-      }
 
-      if (!await fs.pathExists(srcPath)) {
-        console.log(chalk.red(`  ✗ Source not found: ${srcPath}`))
-        continue
+        if (!process.stdout.isTTY) {
+          skipped.push({
+            name: skillName, reason: 'outdated',
+            installed: installedVersion, available: availableVersion ?? '—',
+          })
+          console.error(chalk.dim(`  · Skipped ${skillName} (outdated ${installedVersion} → ${availableVersion ?? '—'}, use --force to overwrite)`))
+          continue
+        }
+
+        const ok = await confirm({
+          message: `${targetName}/${skillName} ${installedVersion} → ${availableVersion ?? '?'}. Overwrite?`,
+          default: false,
+        })
+        if (!ok) {
+          skipped.push({
+            name: skillName, reason: 'outdated',
+            installed: installedVersion, available: availableVersion ?? '—',
+          })
+          console.error(chalk.dim(`  · Skipped ${skillName}`))
+          continue
+        }
       }
 
       try {
         const varDefs = await loadVarDefs(srcPath)
         let varsMap = {}
         if (varDefs.length > 0) {
-          console.log(chalk.bold(`\n  Configure ${skillName}:`))
-          varsMap = await resolveVars(varDefs, buildAutoVars())
+          if (!process.stdout.isTTY) {
+            const autoVars = buildAutoVars()
+            for (const def of varDefs) {
+              autoVars[def.name] = substituteVars(def.default ?? '', autoVars)
+            }
+            varsMap = autoVars
+            console.error(chalk.dim(`  · ${skillName}: using default vars (non-TTY)`))
+          } else {
+            console.error(chalk.bold(`\n  Configure ${skillName}:`))
+            varsMap = await resolveVars(varDefs, buildAutoVars())
+          }
         }
         await copyDir(srcPath, destPath, varsMap)
         installed.push(skillName)
       } catch (err) {
-        console.log(chalk.red(`  ✗ Failed to copy ${targetName}/${skillName}: ${err.message}`))
+        console.error(chalk.red(`  ✗ Failed to copy ${targetName}/${skillName}: ${err.message}`))
+        failed.push({ name: skillName, reason: 'copy_failed', detail: err.message })
       }
     }
 
-    if (installed.length > 0) {
-      summary[targetName] = installed
-    }
+    summary[targetName] = { installed, skipped, failed }
   }
 
   return summary
 }
+
+// ── Hooks ────────────────────────────────────────────────────────────────────
+
+function _hooksDir(scope, projectDir) {
+  return scope === 'user'
+    ? path.join(os.homedir(), '.claude', 'hooks')
+    : path.join(projectDir, '.claude', 'hooks')
+}
+
+function _settingsPath(scope, projectDir) {
+  return scope === 'user'
+    ? path.join(os.homedir(), '.claude', 'settings.json')
+    : path.join(projectDir, '.claude', 'settings.json')
+}
+
+function _hookCommand(hookName, scope) {
+  return scope === 'user'
+    ? `bash ~/.claude/hooks/${hookName}.sh`
+    : `bash "$(git rev-parse --show-toplevel 2>/dev/null || echo .)/.claude/hooks/${hookName}.sh"`
+}
+
+async function _patchSettings(settingsPath, hook, scope, force) {
+  let settings = {}
+  try {
+    settings = JSON.parse(await fs.readFile(settingsPath, 'utf-8'))
+  } catch { /* 文件不存在时从空对象开始 */ }
+
+  if (!settings.hooks) settings.hooks = {}
+  if (!settings.hooks[hook.event]) settings.hooks[hook.event] = []
+
+  const command = _hookCommand(hook.name, scope)
+
+  // 检查是否已有相同 command
+  const alreadyRegistered = settings.hooks[hook.event].some(entry =>
+    Array.isArray(entry.hooks) && entry.hooks.some(h => h.command === command)
+  )
+
+  if (alreadyRegistered && !force) return false
+  if (alreadyRegistered && force) {
+    settings.hooks[hook.event] = settings.hooks[hook.event].filter(entry =>
+      !Array.isArray(entry.hooks) || !entry.hooks.some(h => h.command === command)
+    )
+  }
+
+  const hookEntry = { type: 'command', command }
+  if (hook.timeout)       hookEntry.timeout       = hook.timeout
+  if (hook.statusMessage) hookEntry.statusMessage = hook.statusMessage
+
+  settings.hooks[hook.event].push({
+    matcher: hook.matcher ?? '',
+    hooks: [hookEntry],
+  })
+
+  await fs.ensureDir(path.dirname(settingsPath))
+  await fs.writeFile(settingsPath, JSON.stringify(settings, null, 2) + '\n', 'utf-8')
+  return true
+}
+
+export async function installHooks(hooks, scope, projectDir, force = false) {
+  const hooksDir     = _hooksDir(scope, projectDir)
+  const settingsPath = _settingsPath(scope, projectDir)
+
+  await fs.ensureDir(hooksDir)
+
+  const installed = []
+  const skipped   = []
+  const failed    = []
+
+  for (const hook of hooks) {
+    const destScript   = path.join(hooksDir, `${hook.name}.sh`)
+    const scriptExists = await fs.pathExists(destScript)
+
+    if (scriptExists && !force) {
+      const installedVersion = readHookVersion(destScript)
+      const availableVersion = hook.version
+
+      if (availableVersion && installedVersion === availableVersion) {
+        skipped.push({ name: hook.name, reason: 'up-to-date', version: installedVersion })
+        console.error(chalk.dim(`  · Skipped ${hook.name} (up-to-date ${installedVersion})`))
+        continue
+      }
+
+      if (!process.stdout.isTTY) {
+        skipped.push({
+          name: hook.name, reason: 'outdated',
+          installed: installedVersion, available: availableVersion ?? '—',
+        })
+        console.error(chalk.dim(`  · Skipped ${hook.name} (outdated ${installedVersion} → ${availableVersion}, use --force to overwrite)`))
+        continue
+      }
+
+      const ok = await confirm({
+        message: `${hook.name} ${installedVersion} → ${availableVersion}. Overwrite?`,
+        default: false,
+      })
+      if (!ok) {
+        skipped.push({
+          name: hook.name, reason: 'outdated',
+          installed: installedVersion, available: availableVersion ?? '—',
+        })
+        console.error(chalk.dim(`  · Skipped ${hook.name}`))
+        continue
+      }
+    }
+
+    try {
+      if (!await fs.pathExists(hook.srcPath)) {
+        failed.push({ name: hook.name, reason: 'source_not_found' })
+        console.error(chalk.red(`  ✗ Source not found: ${hook.srcPath}`))
+        continue
+      }
+
+      await fs.copy(hook.srcPath, destScript, { overwrite: true })
+      await fs.chmod(destScript, 0o755)
+      await _patchSettings(settingsPath, hook, scope, force)
+
+      installed.push(hook.name)
+      console.error(chalk.green(`  ✓ ${hook.name} → ${destScript}`))
+    } catch (err) {
+      failed.push({ name: hook.name, reason: 'copy_failed', detail: err.message })
+      console.error(chalk.red(`  ✗ Failed to install ${hook.name}: ${err.message}`))
+    }
+  }
+
+  return { installed, skipped, failed }
+}
+
+export async function uninstallHook(hookName, scope, projectDir) {
+  const hooksDir     = _hooksDir(scope, projectDir)
+  const settingsPath = _settingsPath(scope, projectDir)
+  const destScript   = path.join(hooksDir, `${hookName}.sh`)
+  let removed = false
+
+  if (await fs.pathExists(destScript)) {
+    await fs.remove(destScript)
+    removed = true
+    console.error(chalk.green(`  ✓ Removed ${destScript}`))
+  }
+
+  try {
+    const settings = JSON.parse(await fs.readFile(settingsPath, 'utf-8'))
+    let changed = false
+    for (const event of Object.keys(settings.hooks ?? {})) {
+      const before = settings.hooks[event].length
+      settings.hooks[event] = settings.hooks[event].filter(entry =>
+        !Array.isArray(entry.hooks) ||
+        !entry.hooks.some(h => typeof h.command === 'string' && h.command.includes(`${hookName}.sh`))
+      )
+      if (settings.hooks[event].length !== before) {
+        changed = true
+        removed = true
+        if (settings.hooks[event].length === 0) delete settings.hooks[event]
+      }
+    }
+    if (changed && Object.keys(settings.hooks).length === 0) {
+      delete settings.hooks
+    }
+    if (changed) {
+      await fs.writeFile(settingsPath, JSON.stringify(settings, null, 2) + '\n', 'utf-8')
+      console.error(chalk.green(`  ✓ Unregistered from ${settingsPath}`))
+    }
+  } catch { /* settings.json 不存在，忽略 */ }
+
+  return { removed }
+}

package/lib/targets.js

@@ -1,33 +1,42 @@
 import os from 'os'
 import path from 'path'
 
-const SKILL_TARGETS = ['claude', 'cursor', 'codex']
+const SKILL_TARGETS = ['claude', 'cursor', 'codex', 'openclaw', 'hermes']
+
+export const USER_ONLY_TARGETS = new Set(['openclaw', 'hermes'])
 
 function skillDir(name, scope) {
-  if (scope === 'project') return path.join(process.cwd(), `.${name}`, 'skills')
-  return path.join(os.homedir(), `.${name}`, 'skills')
+  if (USER_ONLY_TARGETS.has(name) || scope !== 'project')
+    return path.join(os.homedir(), `.${name}`, 'skills')
+  return path.join(process.cwd(), `.${name}`, 'skills')
 }
 
 export const TARGETS = {
-  claude: path.join(os.homedir(), '.claude', 'skills'),
-  cursor: path.join(os.homedir(), '.cursor', 'skills'),
-  codex: path.join(os.homedir(), '.codex', 'skills'),
-  shell: path.join(os.homedir(), '.local', 'bin'),
+  claude:   path.join(os.homedir(), '.claude',   'skills'),
+  cursor:   path.join(os.homedir(), '.cursor',   'skills'),
+  codex:    path.join(os.homedir(), '.codex',    'skills'),
+  openclaw: path.join(os.homedir(), '.openclaw', 'skills'),
+  hermes:   path.join(os.homedir(), '.hermes',   'skills'),
+  shell:    path.join(os.homedir(), '.local', 'bin'),
 }
 
 export function buildTargetChoices(scope = 'user') {
-  return SKILL_TARGETS.map(name => {
-    const dir = skillDir(name, scope)
-    return { name: `${name.padEnd(8)} (${dir})`, value: name }
-  })
+  return SKILL_TARGETS
+    .filter(name => scope === 'user' || !USER_ONLY_TARGETS.has(name))
+    .map(name => {
+      const dir = skillDir(name, scope)
+      return { name: `${name.padEnd(8)} (${dir})`, value: name }
+    })
 }
 
 export const TARGET_CHOICES = buildTargetChoices('user')
 
 // 返回选中 targets 的 { name, dir } 列表，all 展开为全部
 export function resolveTargets(selected, scope = 'user') {
-  const allTargets = SKILL_TARGETS.map(name => ({ name, dir: skillDir(name, scope) }))
-  if (selected.includes('all')) return allTargets
+  const eligible = scope === 'user'
+    ? SKILL_TARGETS
+    : SKILL_TARGETS.filter(name => !USER_ONLY_TARGETS.has(name))
+  if (selected.includes('all')) return eligible.map(name => ({ name, dir: skillDir(name, scope) }))
   return selected.map(name => {
     if (!SKILL_TARGETS.includes(name)) throw new Error(`Unknown target: "${name}"`)
     return { name, dir: skillDir(name, scope) }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "harveyz-skill",
-  "version": "0.6.2",
+  "version": "0.7.0",
   "description": "Skill manager for Claude Code, Cursor, and Codex",
   "type": "module",
   "bin": {
@@ -8,16 +8,15 @@
   },
   "scripts": {
     "prepack": "node scripts/generate-npmignore.js",
-    "test": "bats tests/ tools/p-launch/tests/"
+    "test": "bats tests/ tools/p-launch/tests/ && bash scripts/run-skill-tests.sh"
   },
   "files": [
     "bin/",
     "lib/",
     "bundles.json",
     "skills-index.json",
-    "skills/analysis/skill-analyzer/CHANGELOG.md",
-    "skills/analysis/skill-analyzer/SKILL.md",
-    "skills/analysis/skill-analyzer/references/",
+    "CHANGELOG.md",
+    "skills/analysis/skill-analyzer/",
     "skills/harness/diataxis-docs/",
     "skills/harness/full-stack-debug-env/",
     "skills/superpowers-fork/brainstorming/",
@@ -30,7 +29,10 @@
     "skills/task/task-close/",
     "skills/web-fetch/article-fetcher/",
     "skills/writing/mermaid-diagram/",
-    "tools/p-launch/"
+    "skills/design/sync-design-html/",
+    "skills/analysis/git-cleanup/",
+    "tools/p-launch/",
+    "hooks/check-similar-branch/"
   ],
   "engines": {
     "node": ">=18"