harveyz-skill 0.1.2 → 0.2.1

package/bin/cli.js

@@ -1,9 +1,13 @@
 #!/usr/bin/env node
 import { checkbox } from '@inquirer/prompts'
 import chalk from 'chalk'
-import { BUNDLE_CHOICES, resolveSkills } from '../lib/bundles.js'
+import {
+  buildAllChoices, getAllSkillItems, getAllToolItems,
+  resolveSkills, resolveTools,
+  TOOL_BUNDLE_CHOICES,
+} from '../lib/bundles.js'
 import { TARGET_CHOICES, resolveTargets, TARGETS } from '../lib/targets.js'
-import { installSkills } from '../lib/installer.js'
+import { installSkills, installTools } from '../lib/installer.js'
 
 const args = process.argv.slice(2)
 const forceFlag = args.includes('--force')
@@ -12,70 +16,138 @@ const targetIdx = args.indexOf('--target')
 const bundleArg = bundleIdx !== -1 ? args[bundleIdx + 1] : undefined
 const targetArg = targetIdx !== -1 ? args[targetIdx + 1] : undefined
 
-// list 子命令
 if (args[0] === 'list') {
   const { createRequire } = await import('module')
   const require = createRequire(import.meta.url)
-  const bundles = require('../bundles.json')
-  for (const b of bundles) {
-    console.log(chalk.bold(b.name) + ' — ' + b.description)
-    if (b.skills) for (const s of b.skills) console.log('  ' + s)
+  const { bundleMeta, skills, toolBundleMeta = {}, tools = [] } = require('../skills-index.json')
+  const byBundle = {}
+  for (const s of skills) {
+    if (!byBundle[s.bundle]) byBundle[s.bundle] = []
+    byBundle[s.bundle].push(s.path)
+  }
+  for (const [name, paths] of Object.entries(byBundle)) {
+    console.log(chalk.bold(name) + ' — ' + (bundleMeta[name] ?? name))
+    for (const p of paths) console.log('  ' + p)
+  }
+  if (tools.length > 0) {
+    console.log('')
+    console.log(chalk.bold('shell tools:'))
+    for (const t of tools) console.log('  ' + t.name)
   }
   process.exit(0)
 }
 
+const TOOL_BUNDLE_VALUES = new Set(TOOL_BUNDLE_CHOICES.map(c => c.value))
+
+function buildInteractiveChoices() {
+  const toolItems = getAllToolItems()
+  return [
+    ...buildAllChoices(),
+    ...(toolItems.length > 0
+      ? [
+          { type: 'separator', separator: '── shell tools ──' },
+          ...toolItems.map(t => ({ name: t.toolName, value: t })),
+        ]
+      : []),
+    { type: 'separator', separator: '────────────────' },
+    { name: 'all skills', value: 'all' },
+  ]
+}
+
 try {
-  // 解析 bundle 选择
-  let selectedBundles
+  let skillItems = []
+  let toolItems  = []
+
   if (bundleArg) {
-    selectedBundles = bundleArg.split(',').map(s => s.trim()).filter(Boolean)
+    const bundles = bundleArg.split(',').map(s => s.trim()).filter(Boolean)
+    const skillBundles = bundles.filter(b => !TOOL_BUNDLE_VALUES.has(b))
+    const toolBundles  = bundles.filter(b =>  TOOL_BUNDLE_VALUES.has(b))
+    if (skillBundles.length) skillItems = resolveSkills(skillBundles).map(s => ({ kind: 'skill', ...s }))
+    if (toolBundles.length)  toolItems  = resolveTools(toolBundles).map(t => ({ kind: 'tool', ...t }))
   } else {
-    selectedBundles = await checkbox({
-      message: '选择要安装的 bundle（空格多选）:',
-      choices: BUNDLE_CHOICES,
+    const selected = await checkbox({
+      message: 'Select items to install (space to select, enter to confirm):',
+      choices: buildInteractiveChoices(),
     })
-  }
 
-  if (!selectedBundles.length) {
-    console.log(chalk.red('未选择任何 bundle，退出。'))
-    process.exit(1)
-  }
+    if (!selected.length) {
+      console.log(chalk.dim('  · Nothing selected, exiting'))
+      process.exit(0)
+    }
 
-  // 解析 target 选择
-  let selectedTargets
-  if (targetArg) {
-    selectedTargets = targetArg === 'all' ? Object.keys(TARGETS) : [targetArg]
-  } else {
-    selectedTargets = await checkbox({
-      message: '安装到哪些工具（空格多选）:',
-      choices: [
-        ...TARGET_CHOICES,
-        { name: 'all      — 全部工具', value: 'all' },
-      ],
+    const hasAll = selected.includes('all')
+    const items  = selected.filter(s => s !== 'all')
+
+    const selectedSkills = hasAll ? getAllSkillItems() : items.filter(s => s.kind === 'skill')
+    toolItems = items.filter(s => s.kind === 'tool')
+
+    const seen = new Set()
+    skillItems = selectedSkills.filter(s => {
+      if (seen.has(s.skillName)) return false
+      seen.add(s.skillName); return true
     })
   }
 
-  if (!selectedTargets.length) {
-    console.log(chalk.red('未选择任何目标工具，退出。'))
-    process.exit(1)
+  if (!skillItems.length && !toolItems.length) {
+    console.log(chalk.dim('  · Nothing selected, exiting'))
+    process.exit(0)
   }
 
-  const skills = resolveSkills(selectedBundles)
-  const targets = resolveTargets(selectedTargets)
+  // ── Install skills ───────────────────────────────────────────────────────────
+  if (skillItems.length > 0) {
+    let selectedTargets
+    if (targetArg) {
+      selectedTargets = targetArg === 'all' ? Object.keys(TARGETS) : [targetArg]
+    } else {
+      selectedTargets = await checkbox({
+        message: 'Install to which tools (space to select, enter to confirm):',
+        choices: [
+          ...TARGET_CHOICES,
+          { name: 'all      — all tools', value: 'all' },
+        ],
+      })
+    }
 
-  console.log('')
-  const summary = await installSkills(skills, targets, forceFlag)
+    if (selectedTargets.length > 0) {
+      const targets = resolveTargets(selectedTargets)
+      console.log('')
+      const summary = await installSkills(skillItems, targets, forceFlag)
+      console.log('')
+      if (Object.keys(summary).length === 0) {
+        console.log(chalk.dim('  · No skills installed'))
+      } else {
+        console.log(chalk.green.bold('✔ Skills installed:'))
+        for (const [target, names] of Object.entries(summary)) {
+          console.log(`  ${chalk.bold(target)} ← ${names.join(', ')}`)
+        }
+      }
+    }
+  }
 
-  console.log('')
-  if (Object.keys(summary).length === 0) {
-    console.log(chalk.yellow('  没有 skill 被安装。'))
-  } else {
-    console.log(chalk.green('✔ 安装完成：'))
-    for (const [target, names] of Object.entries(summary)) {
-      console.log(`  ${chalk.bold(target)} ← ${names.join(', ')}`)
+  // ── Install shell tools ──────────────────────────────────────────────────────
+  if (toolItems.length > 0) {
+    console.log('')
+    const installed = await installTools(
+      toolItems.map(t => ({ toolName: t.toolName, srcPath: t.srcPath })),
+      TARGETS.shell,
+      forceFlag,
+    )
+    console.log('')
+    if (installed.length === 0) {
+      console.log(chalk.dim('  · No shell tools installed'))
+    } else {
+      console.log(chalk.green.bold('✔ Shell tools installed:'))
+      for (const name of installed) {
+        console.log(`  ${chalk.bold('~/.local/bin')} ← ${name}`)
+      }
+      console.log('')
+      console.log(chalk.yellow.bold('  ⚡ Reload your shell to apply changes:'))
+      console.log('')
+      console.log(`     ${chalk.bold.cyan('source ~/.zshrc')}`)
+      console.log('')
     }
   }
 } catch (err) {
-  console.error(chalk.red('Error: ' + err.message))
+  console.error(chalk.red('  ✗ ' + err.message))
   process.exit(1)
 }

package/lib/bundles.js

@@ -5,34 +5,109 @@ import { fileURLToPath } from 'url'
 const require = createRequire(import.meta.url)
 const __dirname = path.dirname(fileURLToPath(import.meta.url))
 
-const bundleDefs = require('../bundles.json')
-const skillsRoot = path.join(__dirname, '..', 'skills')
+const { bundleMeta, skills: skillDefs, toolBundleMeta = {}, tools: toolDefs = [] } = require('../skills-index.json')
+const repoRoot = path.join(__dirname, '..')
+const skillsRoot = path.join(repoRoot, 'skills')
 
-export const BUNDLE_CHOICES = bundleDefs.map(b => ({
-  name: `${b.name.padEnd(16)} — ${b.description}`,
-  value: b.name,
-}))
+// ── Skills ──────────────────────────────────────────────────────────────────
+const bundleSkills = {}
+for (const skill of skillDefs) {
+  if (!bundleSkills[skill.bundle]) bundleSkills[skill.bundle] = []
+  bundleSkills[skill.bundle].push(skill)
+}
+
+const namedBundles = Object.keys(bundleSkills)
+
+export const BUNDLE_CHOICES = [
+  ...namedBundles.map(name => ({
+    name: `${name.padEnd(16)} — ${bundleMeta[name] ?? name}`,
+    value: name,
+  })),
+  { name: `${'all'.padEnd(16)} — 全部 skill`, value: 'all' },
+]
 
-// 返回选中 bundles 对应的去重 skill 路径列表 { skillName, srcPath }
 export function resolveSkills(selectedBundles) {
-  // 展开 dynamic bundle（all）为所有非 dynamic bundle 的 union
-  const expanded = selectedBundles.flatMap(name => {
-    const def = bundleDefs.find(b => b.name === name)
-    if (!def) throw new Error(`Unknown bundle: "${name}"`)
-    if (def.dynamic) return bundleDefs.filter(b => !b.dynamic).map(b => b.name)
-    return name
-  })
+  const expanded = selectedBundles.includes('all') ? namedBundles : selectedBundles
+
+  const seen = new Set()
+  const result = []
+  for (const bundleName of expanded) {
+    const skills = bundleSkills[bundleName]
+    if (!skills) throw new Error(`Unknown bundle: "${bundleName}"`)
+    for (const skill of skills) {
+      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) })
+    }
+  }
+  return result
+}
+
+// 单个 skill 粒度的选项列表（用于交互式选择）
+// 每个值是 { kind:'skill', skillName, srcPath } 或特殊字符串 'all'
+export function buildAllChoices() {
+  const choices = []
+
+  // ── skill ── 分组
+  for (const [bundleName, skills] of Object.entries(bundleSkills)) {
+    choices.push({ type: 'separator', separator: `── ${bundleName} ──` })
+    for (const skill of skills) {
+      const skillName = skill.path.split('/').pop()
+      choices.push({
+        name: skillName,
+        value: { kind: 'skill', skillName, srcPath: path.join(skillsRoot, skill.path) },
+      })
+    }
+  }
+
+  return choices
+}
+
+// 所有 skill 展开为 { kind:'skill', skillName, srcPath } 列表（对应 all 选项）
+export function getAllSkillItems() {
+  return skillDefs.map(skill => ({
+    kind: 'skill',
+    skillName: skill.path.split('/').pop(),
+    srcPath: path.join(skillsRoot, skill.path),
+  }))
+}
+
+// 所有 tool 展开为 { kind:'tool', toolName, srcPath } 列表
+export function getAllToolItems() {
+  return toolDefs.map(tool => ({
+    kind: 'tool',
+    toolName: tool.name,
+    srcPath: path.join(repoRoot, 'tools', tool.name),
+  }))
+}
+
+// ── Tools ────────────────────────────────────────────────────────────────────
+const bundleTools = {}
+for (const tool of toolDefs) {
+  if (!bundleTools[tool.bundle]) bundleTools[tool.bundle] = []
+  bundleTools[tool.bundle].push(tool)
+}
+
+const namedToolBundles = Object.keys(bundleTools)
+
+export const TOOL_BUNDLE_CHOICES = namedToolBundles.map(name => ({
+  name: `${name.padEnd(16)} — ${toolBundleMeta[name] ?? name}`,
+  value: name,
+}))
+
+export function resolveTools(selectedBundles) {
+  const expanded = selectedBundles.includes('all') ? namedToolBundles : selectedBundles
 
   const seen = new Set()
   const result = []
-  for (const name of expanded) {
-    const def = bundleDefs.find(b => b.name === name)
-    if (!def) continue
-    for (const rel of def.skills) {
-      if (seen.has(rel)) continue
-      seen.add(rel)
-      const skillName = rel.split('/').pop()
-      result.push({ skillName, srcPath: path.join(skillsRoot, rel) })
+  for (const bundleName of expanded) {
+    const tools = bundleTools[bundleName]
+    if (!tools) throw new Error(`Unknown tool bundle: "${bundleName}"`)
+    for (const tool of tools) {
+      if (seen.has(tool.name)) continue
+      seen.add(tool.name)
+      result.push({ toolName: tool.name, srcPath: path.join(repoRoot, 'tools', tool.name) })
     }
   }
   return result

package/lib/installer.js

@@ -1,7 +1,117 @@
 import fs from 'fs-extra'
+import os from 'os'
 import path from 'path'
 import { confirm } from '@inquirer/prompts'
 import chalk from 'chalk'
+import { loadVarDefs, buildAutoVars, resolveVars, substituteVars } from './vars.js'
+
+const BINARY_EXTS = new Set(['.db', '.pyc', '.jpg', '.jpeg', '.png', '.gif', '.webp', '.pdf'])
+const SKIP_NAMES  = new Set(['vars.json', '__pycache__', '.DS_Store'])
+
+async function copyDir(srcDir, destDir, varsMap) {
+  await fs.ensureDir(destDir)
+  const entries = await fs.readdir(srcDir, { withFileTypes: true })
+  for (const entry of entries) {
+    if (SKIP_NAMES.has(entry.name)) continue
+    const src  = path.join(srcDir, entry.name)
+    const dest = path.join(destDir, entry.name)
+    if (entry.isDirectory()) {
+      await copyDir(src, dest, varsMap)
+    } else if (Object.keys(varsMap).length > 0 && !BINARY_EXTS.has(path.extname(entry.name).toLowerCase())) {
+      const content = await fs.readFile(src, 'utf-8').catch(e => { throw new Error(`Failed to read ${src}: ${e.message}`) })
+      await fs.writeFile(dest, substituteVars(content, varsMap), 'utf-8')
+    } else {
+      await fs.copy(src, dest, { overwrite: true })
+    }
+  }
+}
+
+// tools: [{ toolName, srcPath }]
+// targetDir: string — path to ~/.local/bin
+// force: boolean
+export async function installTools(tools, targetDir, force = false) {
+  const exists = await fs.pathExists(targetDir)
+  if (!exists) {
+    console.log(chalk.dim(`  · Creating directory: ${targetDir}`))
+    await fs.ensureDir(targetDir)
+  }
+
+  const installed = []
+  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}`))
+      continue
+    }
+
+    const destExists = await fs.pathExists(destPath)
+    if (destExists && !force) {
+      const ok = await confirm({ message: `${destPath} already exists. Overwrite?`, default: true })
+      if (!ok) {
+        console.log(chalk.dim(`  · Skipped ${toolName}`))
+        continue
+      }
+    }
+
+    try {
+      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])
+          }
+        }
+      }
+      const content = await fs.readFile(scriptSrc, 'utf-8')
+      await fs.writeFile(destPath, substituteVars(content, varsMap), { encoding: 'utf-8', mode: 0o755 })
+      installed.push(toolName)
+      await _patchZshrc(srcPath, toolName)
+    } catch (err) {
+      console.log(chalk.red(`  ✗ Failed to install ${toolName}: ${err.message}`))
+    }
+  }
+
+  return installed
+}
+
+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}`))
+}
+
+async function _patchZshrc(srcPath, toolName) {
+  const snippetPath = path.join(srcPath, 'zshrc.snippet')
+  if (!await fs.pathExists(snippetPath)) return
+
+  const zshrcPath = path.join(os.homedir(), '.zshrc')
+  const marker = `# >>> ${toolName}`
+
+  const existing = await fs.pathExists(zshrcPath)
+    ? await fs.readFile(zshrcPath, 'utf-8')
+    : ''
+
+  if (existing.includes(marker)) {
+    console.log(chalk.dim(`  · ~/.zshrc already has ${toolName} config, skipping`))
+    return
+  }
+
+  const ok = await confirm({
+    message: `Add ${toolName} PATH and alias to ~/.zshrc?`,
+    default: true,
+  })
+  if (!ok) return
+
+  const snippet = await fs.readFile(snippetPath, 'utf-8')
+  await fs.appendFile(zshrcPath, snippet, 'utf-8')
+  console.log(chalk.green(`  ✓ Written to ~/.zshrc`))
+}
 
 // skills: [{ skillName, srcPath }]
 // targets: [{ name, dir }]
@@ -12,7 +122,7 @@ 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.yellow(`  跳过 ${targetName}（目录不存在：${targetDir}）`))
+      console.log(chalk.dim(`  · Skipping ${targetName} (directory not found: ${targetDir})`))
       continue
     }
 
@@ -22,18 +132,29 @@ export async function installSkills(skills, targets, force = false) {
       const destExists = await fs.pathExists(destPath)
 
       if (destExists && !force) {
-        const ok = await confirm({ message: `${targetName}/${skillName} 已存在，覆盖？`, default: false })
+        const ok = await confirm({ message: `${targetName}/${skillName} already exists. Overwrite?`, default: false })
         if (!ok) {
-          console.log(chalk.gray(`  跳过 ${targetName}/${skillName}`))
+          console.log(chalk.dim(`  · Skipped ${targetName}/${skillName}`))
           continue
         }
       }
 
+      if (!await fs.pathExists(srcPath)) {
+        console.log(chalk.red(`  ✗ Source not found: ${srcPath}`))
+        continue
+      }
+
       try {
-        await fs.copy(srcPath, destPath, { overwrite: true })
+        const varDefs = await loadVarDefs(srcPath)
+        let varsMap = {}
+        if (varDefs.length > 0) {
+          console.log(chalk.bold(`\n  Configure ${skillName}:`))
+          varsMap = await resolveVars(varDefs, buildAutoVars())
+        }
+        await copyDir(srcPath, destPath, varsMap)
         installed.push(skillName)
       } catch (err) {
-        console.log(chalk.red(`  复制失败 ${targetName}/${skillName}: ${err.message}`))
+        console.log(chalk.red(`  ✗ Failed to copy ${targetName}/${skillName}: ${err.message}`))
       }
     }
 

package/lib/targets.js

@@ -5,6 +5,7 @@ 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'),
 }
 
 export const TARGET_CHOICES = Object.entries(TARGETS).map(([name, dir]) => ({

package/lib/vars.js

@@ -0,0 +1,34 @@
+// lib/vars.js
+import fs from 'fs-extra'
+import path from 'path'
+import os from 'os'
+import { input } from '@inquirer/prompts'
+
+export function buildAutoVars() {
+  return { HOME: os.homedir() }
+}
+
+export async function loadVarDefs(skillSrcPath) {
+  const varsFile = path.join(skillSrcPath, 'vars.json')
+  if (!await fs.pathExists(varsFile)) return []
+  const defs = await fs.readJson(varsFile)
+  if (!Array.isArray(defs)) throw new Error(`vars.json must be an array (got ${typeof defs})`)
+  return defs
+}
+
+export function substituteVars(text, varsMap) {
+  return text.replace(/\{\{(\w+)\}\}/g, (_, name) => varsMap[name] ?? `{{${name}}}`)
+}
+
+export async function resolveVars(varDefs = [], autoVars) {
+  const result = { ...autoVars }
+  for (const def of varDefs) {
+    const defaultVal = substituteVars(def.default ?? '', autoVars)
+    const value = await input({
+      message: `${def.description}:`,
+      default: defaultVal,
+    })
+    result[def.name] = value
+  }
+  return result
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "harveyz-skill",
-  "version": "0.1.2",
+  "version": "0.2.1",
   "description": "One-click skill installer for Claude Code, Cursor, and Codex",
   "type": "module",
   "bin": {
@@ -13,9 +13,10 @@
     "bin/",
     "lib/",
     "bundles.json",
+    "skills-index.json",
     "skills/analysis/skill-analyzer/CHANGELOG.md",
     "skills/analysis/skill-analyzer/SKILL.md",
-    "skills/document/diataxis-docs/",
+    "skills/harness/diataxis-docs/",
     "skills/harness/full-stack-debug-env/",
     "skills/superpowers-fork/brainstorming/",
     "skills/superpowers-fork/executing-plans/",
@@ -23,7 +24,10 @@
     "skills/superpowers-fork/using-git-worktrees/",
     "skills/superpowers-fork/writing-plans/",
     "skills/task/pm-task-dispatch/",
-    "skills/task/task-close/"
+    "skills/task/task-close/",
+    "skills/web-fetch/article-fetcher/",
+    "skills/writing/mermaid-diagram/",
+    "tools/p-launch/"
   ],
   "engines": {
     "node": ">=18"