rolecraft 0.1.0

package/src/commands/list.test.js

@@ -0,0 +1,92 @@
+import { describe, it, before, after, mock } from 'node:test'
+import assert from 'node:assert/strict'
+import { mkdtempSync } from 'node:fs'
+import { mkdir, rm, writeFile } from 'node:fs/promises'
+import { join } from 'node:path'
+import { tmpdir } from 'node:os'
+
+let tempDir, listModule
+
+before(async () => {
+  tempDir = mkdtempSync(join(tmpdir(), 'rolecraft-list-test-'))
+  process.env.HOME = tempDir
+  await mkdir(join(tempDir, '.agents'), { recursive: true })
+  listModule = await import('./list.js')
+})
+
+after(async () => {
+  await rm(tempDir, { recursive: true, force: true })
+})
+
+function captureLogs() {
+  const logs = []
+  mock.method(console, 'log', (...args) => {
+    if (args.length) logs.push(String(args[0]))
+  })
+  return logs
+}
+
+describe('list command', () => {
+  it('shows no skills message when lock is empty', async () => {
+    const logs = captureLogs()
+
+    await listModule.listCommand()
+
+    assert.ok(logs.some(l => l.includes('No skills installed')))
+  })
+
+  it('lists installed skills with details', async () => {
+    await writeFile(join(tempDir, '.agents', '.skill-lock.json'), JSON.stringify({
+      version: 3,
+      skills: {
+        'test/skill': {
+          installedAt: '2025-01-15T10:00:00.000Z',
+          source: 'owner/repo',
+          sourceType: 'github',
+        },
+      },
+      dismissed: {},
+      lastSelectedAgents: [],
+    }))
+
+    const logs = captureLogs()
+
+    await listModule.listCommand()
+
+    assert.ok(logs.some(l => l.includes('test/skill')))
+    assert.ok(logs.some(l => l.includes('Source: owner/repo')))
+    assert.ok(logs.some(l => l.includes('Type: github')))
+    assert.ok(logs.some(l => l.includes('1 skill(s)')))
+  })
+
+  it('handles skill without optional fields', async () => {
+    await writeFile(join(tempDir, '.agents', '.skill-lock.json'), JSON.stringify({
+      version: 3,
+      skills: { 'minimal/skill': { installedAt: '2025-01-01T00:00:00.000Z' } },
+      dismissed: {},
+      lastSelectedAgents: [],
+    }))
+
+    const logs = captureLogs()
+
+    await listModule.listCommand()
+
+    assert.ok(logs.some(l => l.includes('minimal/skill')))
+    assert.ok(logs.some(l => l.includes('1 skill(s)')))
+  })
+
+  it('handles skill with unknown installedAt', async () => {
+    await writeFile(join(tempDir, '.agents', '.skill-lock.json'), JSON.stringify({
+      version: 3,
+      skills: { 'nodate/skill': {} },
+      dismissed: {},
+      lastSelectedAgents: [],
+    }))
+
+    const logs = captureLogs()
+
+    await listModule.listCommand()
+
+    assert.ok(logs.some(l => l.includes('nodate/skill')))
+  })
+})

package/src/commands/remove.js

@@ -0,0 +1,33 @@
+import { rm } from 'node:fs/promises'
+import { join } from 'node:path'
+import { readLock, removeSkillFromLock, getAgentsDir } from '../utils/lockfile.js'
+
+function normalizeSlug(slug) {
+  return slug.replace(/\//g, '-')
+}
+
+export async function removeCommand(slug) {
+  const lock = await readLock()
+
+  let actualSlug = slug
+  if (!lock.skills[slug]) {
+    const normalized = normalizeSlug(slug)
+    const found = Object.keys(lock.skills).find(k => normalizeSlug(k) === normalized)
+    if (found) {
+      actualSlug = found
+    } else {
+      console.error(`Skill "${slug}" not found.`)
+      process.exit(1)
+    }
+  }
+
+  const dir = join(getAgentsDir(), normalizeSlug(actualSlug))
+  try {
+    await rm(dir, { recursive: true, force: true })
+  } catch {
+    // directory might not exist
+  }
+
+  await removeSkillFromLock(actualSlug)
+  console.log(`Removed ${actualSlug}.`)
+}

package/src/commands/remove.test.js

@@ -0,0 +1,81 @@
+import { describe, it, before, after, mock } from 'node:test'
+import assert from 'node:assert/strict'
+import { mkdtempSync, writeFileSync, mkdirSync } from 'node:fs'
+import { mkdir, rm, readFile, writeFile } from 'node:fs/promises'
+import { join } from 'node:path'
+import { tmpdir } from 'node:os'
+
+let tempDir, removeModule
+
+before(async () => {
+  tempDir = mkdtempSync(join(tmpdir(), 'rolecraft-remove-test-'))
+  process.env.HOME = tempDir
+
+  await mkdir(join(tempDir, '.agents', 'skills', 'test-skill'), { recursive: true })
+
+  const lockPath = join(tempDir, '.agents', '.skill-lock.json')
+  await writeFile(lockPath, JSON.stringify({
+    version: 3,
+    skills: {
+      'test/skill': { name: 'Test Skill' },
+      'other/skill': { name: 'Other Skill' },
+      'exact/skill': { name: 'Exact Skill' },
+    },
+    dismissed: {},
+    lastSelectedAgents: [],
+  }))
+
+  removeModule = await import('./remove.js')
+})
+
+after(async () => {
+  await rm(tempDir, { recursive: true, force: true })
+})
+
+describe('remove command', () => {
+  it('removes an installed skill by exact slug', async () => {
+    const logs = []
+    mock.method(console, 'log', (...args) => {
+      if (args.length) logs.push(String(args[0]))
+    })
+
+    await removeModule.removeCommand('exact/skill')
+
+    const lock = JSON.parse(await readFile(join(tempDir, '.agents', '.skill-lock.json'), 'utf-8'))
+    assert.ok(!lock.skills['exact/skill'])
+    assert.ok(logs.some(l => l.includes('Removed')))
+  })
+
+  it('matches via normalized slug (replacing / with -)', async () => {
+    mkdirSync(join(tempDir, '.agents', 'skills', 'other-skill'), { recursive: true })
+
+    const logs = []
+    mock.method(console, 'log', (...args) => {
+      if (args.length) logs.push(String(args[0]))
+    })
+
+    await removeModule.removeCommand('other-skill')
+
+    const lock = JSON.parse(await readFile(join(tempDir, '.agents', '.skill-lock.json'), 'utf-8'))
+    assert.ok(!lock.skills['other/skill'])
+    assert.ok(logs.some(l => l.includes('Removed')))
+  })
+
+  it('exits with error when skill not found', async () => {
+    const origExit = process.exit
+    const origError = console.error
+    const errors = []
+    console.error = (msg) => errors.push(msg)
+    process.exit = (code) => { throw new Error(`exit:${code}`) }
+
+    await assert.rejects(
+      () => removeModule.removeCommand('nonexistent'),
+      /exit:1/,
+    )
+
+    assert.ok(errors.some(e => e.includes('not found')))
+    process.exit = origExit
+    console.error = origError
+  })
+
+})

package/src/utils/installer.js

@@ -0,0 +1,75 @@
+import { mkdir, cp, writeFile, readFile, access, stat } from 'node:fs/promises'
+import { join, basename } from 'node:path'
+import { homedir } from 'node:os'
+import { getAgentsDir, getClaudeDir, addSkillToLock, getGlobalLockPath, getProjectLockPath } from './lockfile.js'
+
+function normalizeSlug(slug) {
+  return slug.replace(/\//g, '-')
+}
+
+export async function installSkill(resolved, targets) {
+  const slug = resolved.slug
+  const results = []
+
+  for (const target of targets) {
+    let baseDir
+    let label
+
+    switch (target) {
+      case 'agents': {
+        baseDir = getAgentsDir()
+        label = '~/.agents/skills/'
+        break
+      }
+      case 'claude': {
+        baseDir = getClaudeDir()
+        label = '~/.claude/skills/'
+        break
+      }
+      case 'project': {
+        baseDir = join(process.cwd(), '.agents', 'skills')
+        label = './.agents/skills/'
+        break
+      }
+      default:
+        continue
+    }
+
+    const slugDir = join(baseDir, normalizeSlug(slug))
+    const destSkillPath = join(slugDir, 'SKILL.md')
+
+    await mkdir(slugDir, { recursive: true })
+
+    for (const file of resolved.files) {
+      const dst = join(slugDir, file)
+      if (resolved.fileContents?.[file]) {
+        await writeFile(dst, resolved.fileContents[file])
+      } else if (resolved.skillDir) {
+        const src = join(resolved.skillDir, file)
+        try {
+          await stat(src)
+          await cp(src, dst, { recursive: true, force: true })
+        } catch {
+          // skip files that don't exist
+        }
+      }
+    }
+
+    const lockPath = target === 'project'
+      ? getProjectLockPath(process.cwd())
+      : getGlobalLockPath()
+
+    await addSkillToLock(slug, {
+      slug,
+      contentSha: resolved.contentSha || 'local',
+      installedAt: new Date().toISOString(),
+      agents: ['opencode', 'claude-code'],
+      source: resolved.sourcePath,
+      sourceType: resolved.sourceType,
+    }, lockPath)
+
+    results.push({ target, path: slugDir, label })
+  }
+
+  return results
+}

package/src/utils/installer.test.js

@@ -0,0 +1,100 @@
+import { describe, it, before, after } from 'node:test'
+import assert from 'node:assert/strict'
+import { mkdtempSync, mkdirSync, writeFileSync, existsSync, readFileSync } from 'node:fs'
+import { mkdir, rm } from 'node:fs/promises'
+import { join } from 'node:path'
+import { tmpdir } from 'node:os'
+
+let tempDir, installerModule, resolvedSkill
+
+before(async () => {
+  tempDir = mkdtempSync(join(tmpdir(), 'rolecraft-install-test-'))
+  process.env.HOME = tempDir
+
+  const sourceDir = join(tempDir, 'source-skill')
+  mkdirSync(sourceDir, { recursive: true })
+  writeFileSync(join(sourceDir, 'SKILL.md'), '# slug: test/my-skill\nname: my-skill\n# owner: test\nContent')
+  writeFileSync(join(sourceDir, 'helper.js'), 'module.exports = {}\n')
+
+  await mkdir(join(tempDir, '.agents'), { recursive: true })
+
+  resolvedSkill = {
+    slug: 'test/my-skill',
+    name: 'my-skill',
+    owner: 'test',
+    content: '# slug: test/my-skill\nname: my-skill\nContent',
+    files: ['SKILL.md', 'helper.js'],
+    skillDir: sourceDir,
+    sourcePath: sourceDir,
+    sourceType: 'local',
+  }
+
+  installerModule = await import('./installer.js')
+})
+
+after(async () => {
+  await rm(tempDir, { recursive: true, force: true })
+})
+
+describe('installer', () => {
+  it('installs skill to agents directory (global)', async () => {
+    const results = await installerModule.installSkill(resolvedSkill, ['agents'])
+
+    assert.equal(results.length, 1)
+    assert.equal(results[0].target, 'agents')
+
+    const skillDir = join(tempDir, '.agents', 'skills', 'test-my-skill')
+    assert.ok(existsSync(join(skillDir, 'SKILL.md')))
+    assert.ok(existsSync(join(skillDir, 'helper.js')))
+
+    const lock = JSON.parse(readFileSync(join(tempDir, '.agents', '.skill-lock.json'), 'utf-8'))
+    assert.ok(lock.skills['test/my-skill'])
+  })
+
+  it('installs skill to claude directory', async () => {
+    const results = await installerModule.installSkill(resolvedSkill, ['claude'])
+
+    assert.equal(results.length, 1)
+    assert.equal(results[0].target, 'claude')
+
+    const skillDir = join(tempDir, '.claude', 'skills', 'test-my-skill')
+    assert.ok(existsSync(join(skillDir, 'SKILL.md')))
+  })
+
+  it('installs skill to project directory', async () => {
+    const origCwd = process.cwd
+    process.cwd = () => tempDir
+
+    const results = await installerModule.installSkill(resolvedSkill, ['project'])
+
+    assert.equal(results.length, 1)
+    assert.equal(results[0].target, 'project')
+
+    const skillDir = join(tempDir, '.agents', 'skills', 'test-my-skill')
+    assert.ok(existsSync(join(skillDir, 'SKILL.md')))
+
+    process.cwd = origCwd
+  })
+
+  it('installs to multiple targets', async () => {
+    const results = await installerModule.installSkill(resolvedSkill, ['agents', 'project'])
+    assert.equal(results.length, 2)
+  })
+
+  it('skips unknown targets', async () => {
+    const results = await installerModule.installSkill(resolvedSkill, ['unknown'])
+    assert.equal(results.length, 0)
+  })
+
+  it('handles missing source files gracefully', async () => {
+    const badResolved = {
+      ...resolvedSkill,
+      files: ['SKILL.md', 'nonexistent.js'],
+    }
+    const results = await installerModule.installSkill(badResolved, ['agents'])
+    assert.equal(results.length, 1)
+    const skillDir = join(tempDir, '.agents', 'skills', 'test-my-skill')
+    assert.ok(existsSync(join(skillDir, 'SKILL.md')))
+    assert.ok(!existsSync(join(skillDir, 'nonexistent.js')))
+  })
+})

package/src/utils/lockfile.js

@@ -0,0 +1,57 @@
+import { mkdir, readFile, writeFile, access } from 'node:fs/promises'
+import { join, dirname } from 'node:path'
+import { homedir } from 'node:os'
+
+const GLOBAL_AGENTS_DIR = join(homedir(), '.agents')
+const GLOBAL_LOCK_PATH = join(GLOBAL_AGENTS_DIR, '.skill-lock.json')
+const GLOBAL_AGENTS_SKILLS_DIR = join(GLOBAL_AGENTS_DIR, 'skills')
+const CLAUDE_DIR = join(homedir(), '.claude', 'skills')
+
+export function getGlobalLockPath() {
+  return GLOBAL_LOCK_PATH
+}
+
+export function getAgentsDir() {
+  return GLOBAL_AGENTS_SKILLS_DIR
+}
+
+export function getClaudeDir() {
+  return CLAUDE_DIR
+}
+
+export function getProjectLockPath(cwd) {
+  return join(cwd, '.agents', '.skill-lock.json')
+}
+
+async function ensureParentDir(filePath) {
+  await mkdir(dirname(filePath), { recursive: true })
+}
+
+export async function readLock(lockPath = GLOBAL_LOCK_PATH) {
+  try {
+    await access(lockPath)
+    const raw = await readFile(lockPath, 'utf-8')
+    return JSON.parse(raw)
+  } catch {
+    return { version: 3, skills: {}, dismissed: {}, lastSelectedAgents: [] }
+  }
+}
+
+export async function writeLock(data, lockPath = GLOBAL_LOCK_PATH) {
+  await ensureParentDir(lockPath)
+  await writeFile(lockPath, JSON.stringify(data, null, 2) + '\n', 'utf-8')
+}
+
+export async function addSkillToLock(slug, entry, lockPath = GLOBAL_LOCK_PATH) {
+  const lock = await readLock(lockPath)
+  lock.skills[slug] = { ...entry, installedAt: new Date().toISOString() }
+  await writeLock(lock, lockPath)
+  return lock
+}
+
+export async function removeSkillFromLock(slug, lockPath = GLOBAL_LOCK_PATH) {
+  const lock = await readLock(lockPath)
+  delete lock.skills[slug]
+  await writeLock(lock, lockPath)
+  return lock
+}

package/src/utils/lockfile.test.js

@@ -0,0 +1,69 @@
+import { describe, it, before, after } from 'node:test'
+import assert from 'node:assert/strict'
+import { mkdtempSync, readFileSync } from 'node:fs'
+import { mkdir, rm, writeFile } from 'node:fs/promises'
+import { join } from 'node:path'
+import { tmpdir } from 'node:os'
+
+let tempDir, lockModule
+
+before(async () => {
+  tempDir = mkdtempSync(join(tmpdir(), 'rolecraft-lock-test-'))
+  const oldHome = process.env.HOME
+  process.env.HOME = tempDir
+  await mkdir(join(tempDir, '.agents'), { recursive: true })
+  lockModule = await import('./lockfile.js')
+})
+
+after(async () => {
+  await rm(tempDir, { recursive: true, force: true })
+})
+
+describe('lockfile', () => {
+  it('getGlobalLockPath returns path inside homedir', () => {
+    assert.equal(lockModule.getGlobalLockPath(), join(tempDir, '.agents', '.skill-lock.json'))
+  })
+
+  it('getAgentsDir returns path inside homedir', () => {
+    assert.equal(lockModule.getAgentsDir(), join(tempDir, '.agents', 'skills'))
+  })
+
+  it('getClaudeDir returns path inside homedir', () => {
+    assert.equal(lockModule.getClaudeDir(), join(tempDir, '.claude', 'skills'))
+  })
+
+  it('readLock returns default when no file exists', async () => {
+    const lock = await lockModule.readLock()
+    assert.deepEqual(lock, {
+      version: 3, skills: {}, dismissed: {}, lastSelectedAgents: [],
+    })
+  })
+
+  it('readLock parses existing lock file', async () => {
+    const data = { version: 3, skills: { test: { name: 'x' } }, dismissed: {}, lastSelectedAgents: [] }
+    await writeFile(join(tempDir, '.agents', '.skill-lock.json'), JSON.stringify(data))
+    const lock = await lockModule.readLock()
+    assert.deepEqual(lock, data)
+  })
+
+  it('writeLock writes lock file', async () => {
+    const data = { version: 3, skills: { w: {} }, dismissed: {}, lastSelectedAgents: [] }
+    await lockModule.writeLock(data)
+    const written = JSON.parse(readFileSync(join(tempDir, '.agents', '.skill-lock.json'), 'utf-8'))
+    assert.deepEqual(written, data)
+  })
+
+  it('addSkillToLock adds entry and sets installedAt', async () => {
+    await lockModule.addSkillToLock('test/skill', { name: 'Test' })
+    const lock = await lockModule.readLock()
+    assert.equal(lock.skills['test/skill'].name, 'Test')
+    assert.ok(lock.skills['test/skill'].installedAt)
+  })
+
+  it('removeSkillFromLock removes entry', async () => {
+    await lockModule.addSkillToLock('to-remove', {})
+    await lockModule.removeSkillFromLock('to-remove')
+    const lock = await lockModule.readLock()
+    assert.ok(!lock.skills['to-remove'])
+  })
+})

package/src/utils/resolver.js

@@ -0,0 +1,151 @@
+import { readFile, readdir, stat } from 'node:fs/promises'
+import { join, dirname, basename } from 'node:path'
+import { tmpdir, homedir } from 'node:os'
+import { execSync } from 'node:child_process'
+import { randomUUID } from 'node:crypto'
+import { readdirSync, readFileSync } from 'node:fs'
+
+function isGitHubRef(source) {
+  return /^[\w.-]+\/[\w.-]+$/.test(source) && !source.startsWith('/') && !source.startsWith('.')
+}
+
+function isLocalPath(source) {
+  return source.startsWith('/') || source.startsWith('.') || source.startsWith('~')
+}
+
+function parseMetadata(content) {
+  const slugMatch = content.match(/^# slug:\s*(\S+)$/m)
+  const nameMatch = content.match(/^name:\s*(\S+)$/m)
+  const ownerMatch = content.match(/^# owner:\s*(\S+)$/m)
+
+  const name = nameMatch?.[1] || slugMatch?.[1]?.split('/')?.[1] || 'unknown'
+  const slug = slugMatch?.[1] || name
+  const owner = ownerMatch?.[1] || 'local'
+
+  return { name, slug, owner }
+}
+
+function scanForSkill(dir, maxDepth = 3) {
+  const results = []
+
+  function scan(currentDir, depth = 0) {
+    if (depth > maxDepth) return
+    let entries
+    try {
+      entries = readdirSync(currentDir, { withFileTypes: true })
+    } catch {
+      return
+    }
+    for (const entry of entries) {
+      if (entry.name === '.git') continue
+      const fullPath = join(currentDir, entry.name)
+      if (entry.isDirectory()) {
+        scan(fullPath, depth + 1)
+      } else if (entry.name === 'SKILL.md') {
+        try {
+          const c = readFileSync(fullPath, 'utf-8')
+          const meta = parseMetadata(c)
+          results.push({ dir: dirname(fullPath), ...meta, content: c })
+        } catch {
+          // skip unreadable files
+        }
+      }
+    }
+  }
+
+  scan(dir)
+  return results
+}
+
+async function resolveLocal(source) {
+  const expanded = source.replace(/^~/, homedir())
+  const st = await stat(expanded)
+
+  let skillDir
+  if (st.isDirectory()) {
+    skillDir = expanded
+  } else if (st.isFile() && basename(expanded) === 'SKILL.md') {
+    skillDir = dirname(expanded)
+  } else {
+    throw new Error(`Source must be a SKILL.md file or a directory containing one`)
+  }
+
+  const directPath = join(skillDir, 'SKILL.md')
+  try {
+    await stat(directPath)
+    const content = await readFile(directPath, 'utf-8')
+    const meta = parseMetadata(content)
+    const dirEntries = await readdir(skillDir, { withFileTypes: true })
+    const files = dirEntries.filter(e => e.name !== '.git').map(e => e.name)
+    return { ...meta, content, files, skillDir, sourcePath: source, sourceType: 'local' }
+  } catch {
+    // direct SKILL.md not found, scan recursively
+  }
+
+  const found = scanForSkill(skillDir)
+  if (found.length === 0) {
+    throw new Error(`No SKILL.md found in ${skillDir}`)
+  }
+
+  const skill = found[0]
+  const files = readdirSync(skill.dir, { withFileTypes: true })
+    .filter(e => e.name !== '.git')
+    .map(e => e.name)
+
+  return { ...skill, files, skillDir: skill.dir, sourcePath: source, sourceType: 'local' }
+}
+
+async function resolveGitHub(source) {
+  const tmpDir = join(tmpdir(), `rolecraft-${randomUUID().slice(0, 8)}`)
+  const url = `https://github.com/${source}.git`
+
+  try {
+    execSync(`git clone --depth 1 "${url}" "${tmpDir}"`, { stdio: 'pipe', timeout: 30000 })
+  } catch {
+    throw new Error(`Failed to clone GitHub repo ${source}`)
+  }
+
+  const found = scanForSkill(tmpDir)
+
+  if (found.length === 0) {
+    execSync(`rm -rf "${tmpDir}"`)
+    throw new Error(`No SKILL.md found in GitHub repo ${source}`)
+  }
+
+  const skill = found[0]
+  const files = readdirSync(skill.dir, { withFileTypes: true })
+    .filter(e => e.name !== '.git')
+    .map(e => e.name)
+
+  const fileContents = {}
+  for (const f of files) {
+    try {
+      fileContents[f] = readFileSync(join(skill.dir, f), 'utf-8')
+    } catch {
+      // skip unreadable files
+    }
+  }
+
+  execSync(`rm -rf "${tmpDir}"`)
+
+  const owner = source.split('/')[0]
+  return {
+    ...skill,
+    owner: skill.owner === 'local' ? owner : skill.owner,
+    slug: skill.slug === 'unknown' || skill.slug === skill.name ? `${owner}/${skill.name}` : skill.slug,
+    files,
+    fileContents,
+    sourcePath: source,
+    sourceType: 'github',
+  }
+}
+
+export async function resolveSource(source) {
+  if (isGitHubRef(source)) {
+    return await resolveGitHub(source)
+  }
+  if (isLocalPath(source)) {
+    return await resolveLocal(source)
+  }
+  throw new Error(`Invalid source: "${source}". Use a local path (./, /, ~) or GitHub ref (owner/repo)`)
+}