@rfxlamia/skillkit 1.0.0 → 1.1.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rfxlamia/skillkit",
-  "version": "1.0.0",
+  "version": "1.1.0",
   "description": "Interactive CLI installer for SkillKit — Claude Code skills & agents",
   "type": "module",
   "bin": {
@@ -31,5 +31,10 @@
   },
   "homepage": "https://github.com/rfxlamia/skillkit",
   "license": "Apache-2.0",
-  "keywords": ["claude-code", "skills", "ai-agent", "skillkit"]
+  "keywords": [
+    "claude-code",
+    "skills",
+    "ai-agent",
+    "skillkit"
+  ]
 }

package/skills/skillkit/.claude/settings.local.json

@@ -0,0 +1,7 @@
+{
+  "permissions": {
+    "allow": [
+      "mcp__tavily__tavily-search"
+    ]
+  }
+}

package/skills-manifest.json

@@ -213,5 +213,5 @@
       "path": "agents/seo-manager.md"
     }
   ],
-  "generatedAt": "2026-03-14T18:10:24.737Z"
+  "generatedAt": "2026-03-15T04:29:19.063Z"
 }

package/src/banner.js

@@ -5,6 +5,6 @@ export function printBanner(version) {
 ███▄▄ ██▄█▀ ██ ██    ██    ██▄█▀ ██   ██
 ▄▄██▀ ██ ██ ██ ██▄▄▄ ██▄▄▄ ██ ██ ██   ██
 \x1b[0m
-\x1b[90mv${version} · Claude Code Skills Installer\x1b[0m
+\x1b[90mv${version} · Multi-Tool Skills Installer\x1b[0m
 `)
 }

package/src/cli.js

@@ -1,3 +1,4 @@
+// installer/src/cli.js
 import { intro, outro, cancel, isCancel, log } from '@clack/prompts'
 import { readFileSync } from 'fs'
 import { join, dirname } from 'path'
@@ -7,6 +8,7 @@ import { selectScope } from './scope.js'
 import { pickInstallables } from './picker.js'
 import { installSelected } from './install.js'
 import { checkForUpdates } from './update.js'
+import { selectTools, getToolTargets } from './tools.js'
 
 const __dirname = dirname(fileURLToPath(import.meta.url))
 const { version } = JSON.parse(readFileSync(join(__dirname, '..', 'package.json'), 'utf8'))
@@ -17,14 +19,23 @@ export async function run() {
 
   intro('SkillKit Installer')
 
-  const scope = await selectScope()
+  const selectedTools = await selectTools()
+  if (isCancel(selectedTools)) { cancel('Cancelled.'); process.exit(0) }
+
+  const scope = await selectScope(selectedTools)
   if (isCancel(scope)) { cancel('Cancelled.'); process.exit(0) }
 
   const selected = await pickInstallables()
   if (isCancel(selected)) { cancel('Cancelled.'); process.exit(0) }
 
-  const { installed } = await installSelected(selected, scope)
+  const targets = getToolTargets(selectedTools, scope)
+  const { results, totalInstalled } = await installSelected(selected, targets)
+
+  const targetLabels = results
+    .filter(r => r.installed > 0)
+    .map(r => `${r.target.name} (${r.target.scope})`)
+    .join(', ')
 
-  outro(`Done! ${installed} item(s) installed to ${scope.scope} scope.`)
-  log.info(`Restart Claude Code to pick up new skills.`)
+  outro(`Done! ${totalInstalled} item(s) installed to ${targetLabels || 'no targets'}.`)
+  log.info('Restart your coding agent tools to pick up new skills.')
 }

package/src/install.js

@@ -1,3 +1,4 @@
+// installer/src/install.js
 import { cpSync, mkdirSync, existsSync } from 'fs'
 import { join, dirname } from 'path'
 import { fileURLToPath } from 'url'
@@ -6,48 +7,63 @@ import { spinner, log } from '@clack/prompts'
 const __dirname = dirname(fileURLToPath(import.meta.url))
 const PACKAGE_ROOT = join(__dirname, '..')
 
-export async function installSelected({ skills, agents }, { skillsDir, agentsDir }) {
-  // Validate inputs
+export async function installSelected({ skills, agents }, targets) {
   if (!Array.isArray(skills)) throw new TypeError('skills must be an array')
   if (!Array.isArray(agents)) throw new TypeError('agents must be an array')
+  if (!Array.isArray(targets)) throw new TypeError('targets must be an array')
 
   const s = spinner()
   s.start('Installing...')
 
-  let installed = 0
-  const skipped = []
+  const results = []
+  let totalInstalled = 0
 
-  for (const skill of skills) {
-    if (!skill.name || !skill.path) {
-      skipped.push(`invalid-skill-${installed}`)
-      continue
+  for (const target of targets) {
+    let installed = 0
+    const skipped = []
+
+    if (target.skillsDir) {
+      for (const skill of skills) {
+        if (!skill.name || !skill.path) {
+          skipped.push(`invalid-skill-${skipped.length}`)
+          continue
+        }
+        const src = join(PACKAGE_ROOT, skill.path)
+        const dest = join(target.skillsDir, skill.name)
+        if (!existsSync(src)) { skipped.push(skill.name); continue }
+        mkdirSync(dest, { recursive: true })
+        cpSync(src, dest, { recursive: true })
+        installed++
+      }
     }
-    const src = join(PACKAGE_ROOT, skill.path)
-    const dest = join(skillsDir, skill.name)
-    if (!existsSync(src)) { skipped.push(skill.name); continue }
-    mkdirSync(dest, { recursive: true })
-    cpSync(src, dest, { recursive: true })
-    installed++
-  }
 
-  for (const agent of agents) {
-    if (!agent.name || !agent.path) {
-      skipped.push(`invalid-agent-${installed}`)
-      continue
+    if (target.agentsDir) {
+      for (const agent of agents) {
+        if (!agent.name || !agent.path) {
+          skipped.push(`invalid-agent-${skipped.length}`)
+          continue
+        }
+        const src = join(PACKAGE_ROOT, agent.path)
+        const dest = join(target.agentsDir, agent.name + '.md')
+        if (!existsSync(src)) { skipped.push(agent.name); continue }
+        mkdirSync(target.agentsDir, { recursive: true })
+        cpSync(src, dest)
+        installed++
+      }
+    } else if (agents.length > 0) {
+      log.warn(`Agents are not supported for ${target.name} — skipped.`)
     }
-    const src = join(PACKAGE_ROOT, agent.path)
-    const dest = join(agentsDir, agent.name + '.md')
-    if (!existsSync(src)) { skipped.push(agent.name); continue }
-    mkdirSync(agentsDir, { recursive: true })
-    cpSync(src, dest)
-    installed++
+
+    results.push({ target, installed, skipped })
+    totalInstalled += installed
   }
 
-  s.stop(`Installed ${installed} item(s)`)
+  s.stop(`Installed ${totalInstalled} item(s)`)
 
-  if (skipped.length > 0) {
-    log.warn(`Skipped (not found in package): ${skipped.join(', ')}`)
+  const allSkipped = results.flatMap(r => r.skipped)
+  if (allSkipped.length > 0) {
+    log.warn(`Skipped (not found in package): ${allSkipped.join(', ')}`)
   }
 
-  return { installed, skipped }
+  return { results, totalInstalled }
 }

package/src/install.test.js

@@ -1,40 +1,108 @@
+// installer/src/install.test.js
 import { test } from 'node:test'
 import assert from 'node:assert'
 import { mkdtempSync, writeFileSync, mkdirSync, existsSync, rmSync } from 'fs'
-import { join } from 'path'
+import { join, dirname } from 'path'
 import { tmpdir } from 'os'
+import { fileURLToPath } from 'url'
 import { installSelected } from './install.js'
 
+const __dirname = dirname(fileURLToPath(import.meta.url))
+const PACKAGE_ROOT = join(__dirname, '..')
+
 function createTempDir() {
   return mkdtempSync(join(tmpdir(), 'skillkit-test-'))
 }
 
+function makeTarget(skillsDir, agentsDir, name = 'Test Tool') {
+  return { name, scope: 'user', skillsDir, agentsDir }
+}
+
 test('installSelected validates skills is an array', async () => {
   await assert.rejects(
-    installSelected({ skills: 'not-array', agents: [] }, { skillsDir: '/tmp', agentsDir: '/tmp' }),
+    installSelected({ skills: 'not-array', agents: [] }, [makeTarget('/tmp', '/tmp')]),
     /skills must be an array/
   )
 })
 
 test('installSelected validates agents is an array', async () => {
   await assert.rejects(
-    installSelected({ skills: [], agents: 'not-array' }, { skillsDir: '/tmp', agentsDir: '/tmp' }),
+    installSelected({ skills: [], agents: 'not-array' }, [makeTarget('/tmp', '/tmp')]),
     /agents must be an array/
   )
 })
 
+test('installSelected validates targets is an array', async () => {
+  await assert.rejects(
+    installSelected({ skills: [], agents: [] }, 'not-array'),
+    /targets must be an array/
+  )
+})
+
 test('installSelected skips invalid skill objects', async () => {
   const skillsDir = createTempDir()
   const agentsDir = createTempDir()
 
-  const result = await installSelected(
+  const { totalInstalled, results } = await installSelected(
     { skills: [{ name: null }, { name: 'valid', path: 'skills/valid' }], agents: [] },
-    { skillsDir, agentsDir }
+    [makeTarget(skillsDir, agentsDir)]
   )
 
-  assert.strictEqual(result.installed, 0)
-  assert.strictEqual(result.skipped.length, 2)
+  assert.strictEqual(totalInstalled, 0)
+  assert.strictEqual(results[0].skipped.length, 2)
 
   rmSync(skillsDir, { recursive: true })
   rmSync(agentsDir, { recursive: true })
 })
+
+test('installSelected returns results per target', async () => {
+  const dir1 = createTempDir()
+  const dir2 = createTempDir()
+
+  const { results, totalInstalled } = await installSelected(
+    { skills: [], agents: [] },
+    [makeTarget(dir1, null, 'Tool A'), makeTarget(dir2, null, 'Tool B')]
+  )
+
+  assert.strictEqual(results.length, 2)
+  assert.strictEqual(results[0].target.name, 'Tool A')
+  assert.strictEqual(results[1].target.name, 'Tool B')
+  assert.strictEqual(totalInstalled, 0)
+
+  rmSync(dir1, { recursive: true })
+  rmSync(dir2, { recursive: true })
+})
+
+test('installSelected skips agents when agentsDir is null', async () => {
+  const skillsDir = createTempDir()
+
+  const { results } = await installSelected(
+    { skills: [], agents: [{ name: 'test-agent', path: 'agents/test-agent.md' }] },
+    [makeTarget(skillsDir, null)]
+  )
+
+  assert.strictEqual(results[0].target.agentsDir, null)
+
+  rmSync(skillsDir, { recursive: true })
+})
+
+test('installSelected copies skill directory to destination (happy path)', async () => {
+  // Create a source skill directory inside PACKAGE_ROOT (same as install.js uses)
+  const fixtureDir = join(PACKAGE_ROOT, '.test-fixture', 'my-test-skill')
+  mkdirSync(fixtureDir, { recursive: true })
+  writeFileSync(join(fixtureDir, 'SKILL.md'), '# Test Skill')
+
+  const destDir = createTempDir()
+
+  const { totalInstalled, results } = await installSelected(
+    { skills: [{ name: 'my-test-skill', path: '.test-fixture/my-test-skill' }], agents: [] },
+    [makeTarget(destDir, null)]
+  )
+
+  assert.strictEqual(totalInstalled, 1)
+  assert.strictEqual(results[0].installed, 1)
+  assert.ok(existsSync(join(destDir, 'my-test-skill', 'SKILL.md')))
+
+  rmSync(join(PACKAGE_ROOT, '.test-fixture'), { recursive: true })
+  rmSync(destDir, { recursive: true })
+})

package/src/picker.js

@@ -31,7 +31,7 @@ export async function pickInstallables() {
   const mode = await select({
     message: 'What to install?',
     options: [
-      { value: 'all', label: 'Everything (24 skills + 7 agents)' },
+      { value: 'all', label: `Everything (${manifest.skills.length} skills + ${manifest.agents.length} agents)` },
       { value: 'skills-only', label: 'All skills only' },
       { value: 'agents-only', label: 'All agents only' },
       { value: 'pick', label: 'Let me choose...' }
@@ -42,8 +42,13 @@ export async function pickInstallables() {
   if (mode === 'skills-only') return { skills: manifest.skills, agents: [] }
   if (mode === 'agents-only') return { skills: [], agents: manifest.agents }
 
-  // Manual pick
-  const skillChoices = manifest.skills.map(s => ({
+  const sortedSkills = [...manifest.skills].sort((a, b) => {
+    if (a.name === 'skillkit') return -1
+    if (b.name === 'skillkit') return 1
+    return a.name.localeCompare(b.name)
+  })
+
+  const skillChoices = sortedSkills.map(s => ({
     value: s.name,
     label: `${getCategoryDisplay(s)} ${s.name}`,
     hint: s.description.slice(0, 60) + (s.description.length > 60 ? '…' : '')
@@ -68,7 +73,7 @@ export async function pickInstallables() {
   })
 
   return {
-    skills: manifest.skills.filter(s => selectedSkills.includes(s.name)),
+    skills: sortedSkills.filter(s => selectedSkills.includes(s.name)),
     agents: manifest.agents.filter(a => selectedAgents.includes(a.name))
   }
 }

package/src/scope.js

@@ -1,57 +1,26 @@
+// installer/src/scope.js
 import { select, log } from '@clack/prompts'
-import { homedir } from 'os'
-import { join } from 'path'
-import { existsSync } from 'fs'
-
-export async function selectScope() {
-  const userSkillsPath = join(homedir(), '.claude', 'skills')
-  const projectSkillsPath = join(process.cwd(), '.claude', 'skills')
-  const projectExists = existsSync(join(process.cwd(), '.claude', 'skills'))
 
+export async function selectScope(selectedTools = []) {
   const scope = await select({
     message: 'Install to:',
     options: [
       {
         value: 'user',
-        label: `User scope  ~/.claude/skills/`,
+        label: 'User scope',
         hint: 'available in all projects'
       },
       {
         value: 'project',
-        label: `Project scope  ./.claude/skills/`,
-        hint: projectExists ? 'detected .claude/skills/ here' : `will create ${projectSkillsPath}`
+        label: 'Project scope',
+        hint: 'this project only'
       }
     ]
   })
 
-  if (scope === 'user') {
-    return {
-      scope: 'user',
-      skillsDir: userSkillsPath,
-      agentsDir: join(homedir(), '.claude', 'agents')
-    }
-  }
-
-  return {
-    scope: 'project',
-    skillsDir: projectSkillsPath,
-    agentsDir: join(process.cwd(), '.claude', 'agents')
-  }
-}
-
-// Export for testing
-export function getUserScope() {
-  return {
-    scope: 'user',
-    skillsDir: join(homedir(), '.claude', 'skills'),
-    agentsDir: join(homedir(), '.claude', 'agents')
+  if (selectedTools.includes('codex') && scope === 'project') {
+    log.warn('Codex does not support project scope — skills will be installed to ~/.agents/skills/skillkit/')
   }
-}
 
-export function getProjectScope() {
-  return {
-    scope: 'project',
-    skillsDir: join(process.cwd(), '.claude', 'skills'),
-    agentsDir: join(process.cwd(), '.claude', 'agents')
-  }
+  return scope
 }

package/src/scope.test.js

@@ -1,19 +1,15 @@
+// installer/src/scope.test.js
 import { test } from 'node:test'
 import assert from 'node:assert'
-import { homedir } from 'os'
-import { join } from 'path'
-import { getUserScope, getProjectScope } from './scope.js'
+import { selectScope } from './scope.js'
 
-test('getUserScope returns correct paths', () => {
-  const scope = getUserScope()
-  assert.strictEqual(scope.scope, 'user')
-  assert.strictEqual(scope.skillsDir, join(homedir(), '.claude', 'skills'))
-  assert.strictEqual(scope.agentsDir, join(homedir(), '.claude', 'agents'))
+test('selectScope is an async function', () => {
+  const AsyncFunction = (async () => {}).constructor
+  assert.ok(selectScope instanceof AsyncFunction)
 })
 
-test('getProjectScope returns correct paths', () => {
-  const scope = getProjectScope()
-  assert.strictEqual(scope.scope, 'project')
-  assert.strictEqual(scope.skillsDir, join(process.cwd(), '.claude', 'skills'))
-  assert.strictEqual(scope.agentsDir, join(process.cwd(), '.claude', 'agents'))
+test('getUserScope and getProjectScope are no longer exported', async () => {
+  const mod = await import('./scope.js')
+  assert.strictEqual(mod.getUserScope, undefined)
+  assert.strictEqual(mod.getProjectScope, undefined)
 })

package/src/tools.js

@@ -0,0 +1,76 @@
+// installer/src/tools.js
+import { multiselect } from '@clack/prompts'
+import { homedir } from 'os'
+import { join } from 'path'
+
+export async function selectTools() {
+  return multiselect({
+    message: 'Install to which tools?',
+    options: [
+      { value: 'claude-code', label: 'Claude Code', hint: '~/.claude/skills/' },
+      { value: 'opencode', label: 'OpenCode', hint: '~/.config/opencode/skills/' },
+      { value: 'codex', label: 'Codex', hint: '~/.agents/skills/' },
+      { value: 'copilot', label: 'GitHub Copilot', hint: '~/.copilot/skills/' }
+    ],
+    required: true
+  })
+}
+
+export function getToolTargets(selectedTools, scope) {
+  if (!selectedTools.length) return []
+
+  const home = homedir()
+  const cwd = process.cwd()
+  const isUser = scope === 'user'
+
+  const resolve = {
+    'claude-code': {
+      name: 'Claude Code',
+      scope,
+      skillsDir: isUser ? join(home, '.claude', 'skills') : join(cwd, '.claude', 'skills'),
+      agentsDir: isUser ? join(home, '.claude', 'agents') : join(cwd, '.claude', 'agents')
+    },
+    'opencode': {
+      name: 'OpenCode',
+      scope,
+      skillsDir: isUser
+        ? join(home, '.config', 'opencode', 'skills', 'skillkit')
+        : join(cwd, '.opencode', 'skills'),
+      agentsDir: isUser
+        ? join(home, '.config', 'opencode', 'agents')
+        : join(cwd, '.opencode', 'agents')
+    },
+    'codex': {
+      name: 'Codex',
+      scope: 'user',
+      skillsDir: join(home, '.agents', 'skills', 'skillkit'),
+      agentsDir: null
+    },
+    'copilot': {
+      name: 'GitHub Copilot',
+      scope: isUser ? 'user' : 'project',
+      skillsDir: join(home, '.copilot', 'skills'),
+      agentsDir: isUser
+        ? join(home, '.claude', 'agents')
+        : join(cwd, '.github', 'agents')
+    }
+  }
+
+  const targets = selectedTools
+    .filter(id => resolve[id])
+    .map(id => ({ ...resolve[id] }))
+
+  // Dedup: if skillsDir or agentsDir appears more than once, null it in later targets
+  const seenSkills = new Set()
+  const seenAgents = new Set()
+
+  for (const t of targets) {
+    if (seenSkills.has(t.skillsDir)) t.skillsDir = null
+    else seenSkills.add(t.skillsDir)
+
+    if (t.agentsDir && seenAgents.has(t.agentsDir)) t.agentsDir = null
+    else if (t.agentsDir) seenAgents.add(t.agentsDir)
+  }
+
+  return targets.filter(t => t.skillsDir || t.agentsDir)
+}

package/src/tools.test.js

@@ -0,0 +1,80 @@
+// installer/src/tools.test.js
+import { test } from 'node:test'
+import assert from 'node:assert'
+import { homedir } from 'os'
+import { join } from 'path'
+import { getToolTargets } from './tools.js'
+
+const home = homedir()
+const cwd = process.cwd()
+
+test('getToolTargets returns empty array for empty selection', () => {
+  const result = getToolTargets([], 'user')
+  assert.deepStrictEqual(result, [])
+})
+
+test('getToolTargets claude-code user scope', () => {
+  const [t] = getToolTargets(['claude-code'], 'user')
+  assert.strictEqual(t.name, 'Claude Code')
+  assert.strictEqual(t.scope, 'user')
+  assert.strictEqual(t.skillsDir, join(home, '.claude', 'skills'))
+  assert.strictEqual(t.agentsDir, join(home, '.claude', 'agents'))
+})
+
+test('getToolTargets claude-code project scope', () => {
+  const [t] = getToolTargets(['claude-code'], 'project')
+  assert.strictEqual(t.scope, 'project')
+  assert.strictEqual(t.skillsDir, join(cwd, '.claude', 'skills'))
+  assert.strictEqual(t.agentsDir, join(cwd, '.claude', 'agents'))
+})
+
+test('getToolTargets opencode user scope', () => {
+  const [t] = getToolTargets(['opencode'], 'user')
+  assert.strictEqual(t.name, 'OpenCode')
+  assert.strictEqual(t.skillsDir, join(home, '.config', 'opencode', 'skills', 'skillkit'))
+  assert.strictEqual(t.agentsDir, join(home, '.config', 'opencode', 'agents'))
+})
+
+test('getToolTargets opencode project scope', () => {
+  const [t] = getToolTargets(['opencode'], 'project')
+  assert.strictEqual(t.skillsDir, join(cwd, '.opencode', 'skills'))
+  assert.strictEqual(t.agentsDir, join(cwd, '.opencode', 'agents'))
+})
+
+test('getToolTargets codex user scope — agentsDir is null', () => {
+  const [t] = getToolTargets(['codex'], 'user')
+  assert.strictEqual(t.name, 'Codex')
+  assert.strictEqual(t.skillsDir, join(home, '.agents', 'skills', 'skillkit'))
+  assert.strictEqual(t.agentsDir, null)
+})
+
+test('getToolTargets codex project scope — still resolves to user path', () => {
+  const [t] = getToolTargets(['codex'], 'project')
+  assert.strictEqual(t.scope, 'user')
+  assert.strictEqual(t.skillsDir, join(home, '.agents', 'skills', 'skillkit'))
+  assert.strictEqual(t.agentsDir, null)
+})
+
+test('getToolTargets copilot user scope', () => {
+  const [t] = getToolTargets(['copilot'], 'user')
+  assert.strictEqual(t.name, 'GitHub Copilot')
+  assert.strictEqual(t.skillsDir, join(home, '.copilot', 'skills'))
+  assert.strictEqual(t.agentsDir, join(home, '.claude', 'agents'))
+})
+
+test('getToolTargets copilot project scope — skills still user path, agents project path', () => {
+  const [t] = getToolTargets(['copilot'], 'project')
+  assert.strictEqual(t.skillsDir, join(home, '.copilot', 'skills'))
+  assert.strictEqual(t.agentsDir, join(cwd, '.github', 'agents'))
+})
+
+test('getToolTargets deduplicates agentsDir for claude-code + copilot (user)', () => {
+  const targets = getToolTargets(['claude-code', 'copilot'], 'user')
+  assert.strictEqual(targets.length, 2)
+  const agentsDirs = targets.map(t => t.agentsDir).filter(Boolean)
+  const uniqueAgentsDirs = [...new Set(agentsDirs)]
+  assert.strictEqual(agentsDirs.length, uniqueAgentsDirs.length, 'no duplicate agentsDirs')
+  // Claude Code gets agentsDir, Copilot gets null (deduped)
+  assert.strictEqual(targets[0].agentsDir, join(home, '.claude', 'agents'))
+  assert.strictEqual(targets[1].agentsDir, null)
+})