simba-skills 0.1.2 → 0.3.0

package/README.md

@@ -1,5 +1,9 @@
 # Simba
 
+<p align="center">
+  <img src="assets/simba.jpg" alt="Simba the cat" width="600">
+</p>
+
 [![npm version](https://img.shields.io/npm/v/simba-skills)](https://www.npmjs.com/package/simba-skills)
 [![License: MIT](https://img.shields.io/badge/License-MIT-blue.svg)](LICENSE)
 

package/package.json

@@ -1,9 +1,10 @@
 {
   "name": "simba-skills",
-  "version": "0.1.2",
+  "version": "0.3.0",
   "description": "AI skills manager - central store with symlink-based distribution across 14+ coding agents",
   "publishConfig": {
-    "access": "public"
+    "access": "public",
+    "provenance": true
   },
   "type": "module",
   "license": "MIT",
@@ -30,7 +31,7 @@
   },
   "files": [
     "src",
-    "!src/**/*.test.ts"
+    "!assets"
   ],
   "scripts": {
     "dev": "bun run src/index.ts",

package/src/commands/adopt.ts

@@ -70,9 +70,12 @@ export async function runAdopt(options: AdoptOptions): Promise<void> {
   }
 
   const toAdopt: Array<{ name: string; skill: DiscoveredSkill }> = []
+  const toTakeover: Array<{ name: string; skills: DiscoveredSkill[] }> = []
+  
   for (const [name, skills] of byName) {
     if (await skillsStore.hasSkill(name)) {
-      console.log(`  Skipping ${name} (already in store)`)
+      // Already in store - take over rogue copies
+      toTakeover.push({ name, skills })
       continue
     }
 
@@ -86,12 +89,14 @@ export async function runAdopt(options: AdoptOptions): Promise<void> {
     }
   }
 
-  if (toAdopt.length === 0) {
+  if (toAdopt.length === 0 && toTakeover.length === 0) {
     console.log("\nNo new skills to adopt.")
     return
   }
 
-  console.log(`\nAdopting ${toAdopt.length} skills...`)
+  if (toAdopt.length > 0) {
+    console.log(`\nAdopting ${toAdopt.length} skills...`)
+  }
 
   if (options.dryRun) {
     for (const { name, skill } of toAdopt) {
@@ -117,6 +122,33 @@ export async function runAdopt(options: AdoptOptions): Promise<void> {
     console.log(`  Adopted: ${name} (from ${skill.agentId})`)
   }
 
+  // Take over rogue copies (skill already in store, but real dirs exist at agents)
+  if (toTakeover.length > 0) {
+    console.log(`\nTaking over ${toTakeover.length} rogue skills...`)
+    
+    if (!options.dryRun) {
+      for (const { name, skills } of toTakeover) {
+        for (const skill of skills) {
+          await rm(skill.path, { recursive: true })
+          await createSymlink(join(options.skillsDir, name), skill.path)
+          
+          // Update registry assignment
+          if (!registry.skills[name].assignments[skill.agentId]) {
+            registry.skills[name].assignments[skill.agentId] = { type: "directory" }
+          }
+          
+          console.log(`  Replaced: ${name} (${skill.agentId})`)
+        }
+      }
+    } else {
+      for (const { name, skills } of toTakeover) {
+        for (const skill of skills) {
+          console.log(`  Would replace: ${name} (${skill.agentId})`)
+        }
+      }
+    }
+  }
+
   await registryStore.save(registry)
   console.log("\nAdoption complete!")
 }

package/src/commands/doctor.ts

@@ -1,5 +1,5 @@
 import { defineCommand } from "citty"
-import { access } from "node:fs/promises"
+import { access, rm } from "node:fs/promises"
 import { join } from "node:path"
 import * as p from "@clack/prompts"
 import { ConfigStore } from "../core/config-store"
@@ -164,6 +164,17 @@ export default defineCommand({
       console.log(`Fixed: ${broken.skill} (${broken.agent})`)
     }
 
+    for (const rogue of results.rogue) {
+      const agent = detected[rogue.agent]
+      if (!agent) continue
+
+      // Delete rogue directory/file and replace with symlink
+      await rm(rogue.path, { recursive: true })
+      const expectedTarget = join(getSkillsDir(), rogue.skill)
+      await createSymlink(expectedTarget, rogue.path)
+      console.log(`Fixed rogue: ${rogue.skill} (${rogue.agent})`)
+    }
+
     console.log("\nRepairs complete!")
   },
 })

package/src/commands/install.ts

@@ -281,6 +281,7 @@ export interface InstallOptions {
   skillsDir: string
   registryPath: string
   useSSH: boolean
+  skillName?: string // Install specific skill by name, skip selection
   onSelect: (skills: DiscoveredSkill[]) => Promise<string[]>
 }
 
@@ -346,16 +347,30 @@ export async function runInstall(options: InstallOptions): Promise<void> {
       return
     }
 
-    console.log(`\nFound ${discovered.length} skills:`)
-    for (const skill of discovered) {
-      console.log(`  * ${skill.name}${skill.description ? ` - ${skill.description}` : ""}`)
-    }
+    let selected: string[]
 
-    const selected = await options.onSelect(discovered)
+    if (options.skillName) {
+      // Direct install of specific skill
+      const skill = discovered.find(s => s.name === options.skillName)
+      if (!skill) {
+        console.log(`Skill "${options.skillName}" not found in source.`)
+        console.log(`Available skills: ${discovered.map(s => s.name).join(", ")}`)
+        return
+      }
+      selected = [options.skillName]
+      console.log(`Installing skill: ${options.skillName}`)
+    } else {
+      console.log(`\nFound ${discovered.length} skills:`)
+      for (const skill of discovered) {
+        console.log(`  * ${skill.name}${skill.description ? ` - ${skill.description}` : ""}`)
+      }
 
-    if (selected.length === 0) {
-      console.log("No skills selected.")
-      return
+      selected = await options.onSelect(discovered)
+
+      if (selected.length === 0) {
+        console.log("No skills selected.")
+        return
+      }
     }
 
     for (const name of selected) {
@@ -458,6 +473,7 @@ export default defineCommand({
   args: {
     source: { type: "positional", description: "GitHub repo (user/repo) or local path", required: true },
     ssh: { type: "boolean", description: "Use SSH for GitHub repos (for private repos)", default: false },
+    skill: { type: "string", description: "Install specific skill by name (skip selection)", required: false },
   },
   async run({ args }) {
     await runInstall({
@@ -465,6 +481,7 @@ export default defineCommand({
       skillsDir: getSkillsDir(),
       registryPath: getRegistryPath(),
       useSSH: args.ssh,
+      skillName: args.skill,
       onSelect: async (skills) => {
         const result = await p.multiselect({
           message: "Select skills to install:",

package/src/commands/update.ts

@@ -1,9 +1,10 @@
 import { defineCommand } from "citty"
-import { readFile, mkdir, rm } from "node:fs/promises"
-import { join } from "node:path"
+import { readFile, readdir, mkdir, rm } from "node:fs/promises"
+import { join, relative } from "node:path"
 import * as p from "@clack/prompts"
 import simpleGit from "simple-git"
 import { tmpdir } from "node:os"
+import { createHash } from "node:crypto"
 import { RegistryStore } from "../core/registry-store"
 import { SkillsStore } from "../core/skills-store"
 import { getSkillsDir, getRegistryPath } from "../utils/paths"
@@ -12,6 +13,50 @@ import { discoverSkills } from "./install"
 import type { ManagedSkill, InstallSource } from "../core/types"
 import matter from "gray-matter"
 
+/**
+ * Recursively get all files in a directory (sorted for deterministic hashing)
+ */
+async function getAllFiles(dir: string): Promise<string[]> {
+  const files: string[] = []
+  
+  async function scan(currentDir: string): Promise<void> {
+    const entries = await readdir(currentDir, { withFileTypes: true })
+    for (const entry of entries) {
+      const fullPath = join(currentDir, entry.name)
+      if (entry.isDirectory()) {
+        await scan(fullPath)
+      } else {
+        files.push(relative(dir, fullPath))
+      }
+    }
+  }
+  
+  await scan(dir)
+  return files.sort()
+}
+
+/**
+ * Compute a content hash for an entire skill directory.
+ * Hash includes: sorted file paths + their contents
+ */
+async function hashSkillDir(dir: string): Promise<string> {
+  const files = await getAllFiles(dir)
+  const hash = createHash("sha256")
+  
+  for (const file of files) {
+    // Include file path in hash (detects renames/additions/deletions)
+    hash.update(file)
+    hash.update("\0")
+    
+    // Include file content
+    const content = await readFile(join(dir, file))
+    hash.update(content)
+    hash.update("\0")
+  }
+  
+  return hash.digest("hex")
+}
+
 interface SkillUpdate {
   skill: ManagedSkill
   newPath: string
@@ -119,16 +164,23 @@ export async function runUpdate(options: UpdateOptions): Promise<void> {
           continue
         }
 
-        const existingPath = join(options.skillsDir, skill.name, "SKILL.md")
-        const existingContent = await readFile(existingPath, "utf-8")
-        const newContent = await readFile(join(remote.path, "SKILL.md"), "utf-8")
-
-        const comparison = compareFiles(existingContent, newContent, "SKILL.md")
+        const localDir = join(options.skillsDir, skill.name)
+        
+        // Hash entire directories to detect any file changes
+        const [localHash, remoteHash] = await Promise.all([
+          hashSkillDir(localDir),
+          hashSkillDir(remote.path)
+        ])
 
-        if (comparison.identical) {
+        if (localHash === remoteHash) {
           console.log(`  ✓ ${skill.name}: up to date`)
         } else {
           console.log(`  ↑ ${skill.name}: update available`)
+          
+          // Still read SKILL.md for version display purposes
+          const existingContent = await readFile(join(localDir, "SKILL.md"), "utf-8")
+          const newContent = await readFile(join(remote.path, "SKILL.md"), "utf-8")
+          
           allUpdates.push({
             skill,
             newPath: remote.path,

package/src/core/config-store.ts

@@ -13,7 +13,7 @@ const AGENT_DEFINITIONS: [string, string, string, string, string][] = [
     ["windsurf", "Windsurf", "Windsurf", "~/.codeium/windsurf/skills", ".windsurf/skills"],
     ["amp", "Amp", "Amp", "~/.config/agents/skills", ".agents/skills"],
     ["goose", "Goose", "Goose", "~/.config/goose/skills", ".goose/skills"],
-    ["opencode", "OpenCode", "OpenCode", "~/.config/opencode/skill", ".opencode/skill"],
+    ["opencode", "OpenCode", "OpenCode", "~/.config/opencode/skills", ".opencode/skills"],
     ["kilo", "Kilo Code", "Kilo", "~/.kilocode/skills", ".kilocode/skills"],
     ["roo", "Roo Code", "Roo", "~/.roo/skills", ".roo/skills"],
     ["antigravity", "Antigravity", "Antigrav", "~/.gemini/antigravity/skills", ".agent/skills"],

package/src/index.ts

@@ -1,6 +1,6 @@
 #!/usr/bin/env bun
 
-import { defineCommand, runMain } from "citty"
+import { defineCommand, runMain, showUsage } from "citty"
 
 const main = defineCommand({
   meta: {
@@ -8,6 +8,11 @@ const main = defineCommand({
     version: "0.2.0",
     description: "AI skills manager",
   },
+  async run({ cmd, rawArgs }) {
+    if (rawArgs.length === 0) {
+      await showUsage(cmd)
+    }
+  },
   subCommands: {
     adopt: () => import("./commands/adopt").then((m) => m.default),
     assign: () => import("./commands/assign").then((m) => m.default),

package/src/tui/matrix.ts

@@ -6,8 +6,7 @@ import { AgentRegistry } from "../core/agent-registry"
 import { getRegistryPath, getSkillsDir, getConfigPath, expandPath } from "../utils/paths"
 import type { Agent, Registry } from "../core/types"
 
-// Cast to any to access showCursor (missing from @types/terminal-kit)
-const term = termkit.terminal as typeof termkit.terminal & { showCursor: () => void }
+const term = termkit.terminal
 
 interface MatrixState {
   skills: string[]
@@ -102,7 +101,7 @@ export async function runMatrixTUI(): Promise<void> {
 
     term("\n")
     term("─".repeat(21 + state.agents.length * 10) + "\n")
-    term.dim("[Space] Toggle  [a] Assign all  [n] None  [q] Quit\n")
+    term.dim("[Space] Toggle  [a] Assign all  [n] None  [Enter] Confirm  [q] Cancel\n")
   }
 
   const toggle = async () => {
@@ -110,29 +109,43 @@ export async function runMatrixTUI(): Promise<void> {
     const agent = state.agents[state.cursorCol]
     const skill = state.registry.skills[skillName]
 
-    if (skill.assignments[agent.id]) {
-      await skillsStore.unassignSkill(skillName, expandPath(agent.globalPath))
-      delete skill.assignments[agent.id]
-    } else {
-      await skillsStore.assignSkill(skillName, expandPath(agent.globalPath), { type: "directory" })
-      skill.assignments[agent.id] = { type: "directory" }
+    try {
+      if (skill.assignments[agent.id]) {
+        await skillsStore.unassignSkill(skillName, expandPath(agent.globalPath))
+        delete skill.assignments[agent.id]
+      } else {
+        await skillsStore.assignSkill(skillName, expandPath(agent.globalPath), { type: "directory" })
+        skill.assignments[agent.id] = { type: "directory" }
+      }
+      await registryStore.save(state.registry)
+    } catch (err) {
+      term.moveTo(1, state.skills.length + 8)
+      term.yellow(`Error: ${(err as Error).message}\n`)
     }
-
-    await registryStore.save(state.registry)
   }
 
   const assignAll = async () => {
     const skillName = state.skills[state.cursorRow]
     const skill = state.registry.skills[skillName]
+    const errors: string[] = []
 
     for (const agent of state.agents) {
       if (!skill.assignments[agent.id]) {
-        await skillsStore.assignSkill(skillName, expandPath(agent.globalPath), { type: "directory" })
-        skill.assignments[agent.id] = { type: "directory" }
+        try {
+          await skillsStore.assignSkill(skillName, expandPath(agent.globalPath), { type: "directory" })
+          skill.assignments[agent.id] = { type: "directory" }
+        } catch (err) {
+          errors.push(`${agent.name}: ${(err as Error).message}`)
+        }
       }
     }
 
     await registryStore.save(state.registry)
+    
+    if (errors.length > 0) {
+      term.moveTo(1, state.skills.length + 8)
+      term.yellow(`Errors:\n${errors.join("\n")}\n`)
+    }
   }
 
   const unassignAll = async () => {
@@ -176,11 +189,18 @@ export async function runMatrixTUI(): Promise<void> {
       case "n":
         await unassignAll()
         break
+      case "ENTER":
+        term.clear()
+        term.hideCursor(false)
+        term.grabInput(false)
+        term.green("Changes saved.\n")
+        process.exit(0)
       case "q":
       case "CTRL_C":
         term.clear()
-        term.showCursor()
+        term.hideCursor(false)
         term.grabInput(false)
+        term.yellow("Cancelled.\n")
         process.exit(0)
     }
 

package/src/utils/symlinks.ts

@@ -3,7 +3,29 @@ import { dirname } from "node:path"
 
 export async function createSymlink(source: string, target: string): Promise<void> {
   await mkdir(dirname(target), { recursive: true })
-  await symlink(source, target)
+  try {
+    await symlink(source, target)
+  } catch (err) {
+    if ((err as NodeJS.ErrnoException).code === "EEXIST") {
+      // Already exists - check if it's a symlink pointing to the right place
+      const existing = await getSymlinkTarget(target)
+      if (existing === source) return // Already correct symlink
+      
+      // Check what we're dealing with
+      const stat = await lstat(target)
+      if (stat.isSymbolicLink()) {
+        await unlink(target)
+      } else if (stat.isDirectory()) {
+        // Real directory - don't delete, throw error
+        throw new Error(`Cannot create symlink: ${target} is a directory (not managed by simba)`)
+      } else {
+        await unlink(target)
+      }
+      await symlink(source, target)
+    } else {
+      throw err
+    }
+  }
 }
 
 export async function isSymlink(path: string): Promise<boolean> {
@@ -17,7 +39,15 @@ export async function isSymlink(path: string): Promise<boolean> {
 
 export async function removeSymlink(path: string): Promise<void> {
   try {
-    await unlink(path)
+    const stat = await lstat(path)
+    if (stat.isSymbolicLink()) {
+      await unlink(path)
+    } else if (stat.isDirectory()) {
+      // Real directory - don't delete, it's not managed by simba
+      throw new Error(`Cannot remove: ${path} is a directory (not managed by simba)`)
+    } else {
+      await unlink(path)
+    }
   } catch (err) {
     if ((err as NodeJS.ErrnoException).code !== "ENOENT") {
       throw err