simba-skills 0.1.2

package/src/commands/update.ts

@@ -0,0 +1,251 @@
+import { defineCommand } from "citty"
+import { readFile, mkdir, rm } from "node:fs/promises"
+import { join } from "node:path"
+import * as p from "@clack/prompts"
+import simpleGit from "simple-git"
+import { tmpdir } from "node:os"
+import { RegistryStore } from "../core/registry-store"
+import { SkillsStore } from "../core/skills-store"
+import { getSkillsDir, getRegistryPath } from "../utils/paths"
+import { compareFiles, renderDiff } from "../utils/diff"
+import { discoverSkills } from "./install"
+import type { ManagedSkill, InstallSource } from "../core/types"
+import matter from "gray-matter"
+
+interface SkillUpdate {
+  skill: ManagedSkill
+  newPath: string
+  newContent: string
+  existingContent: string
+}
+
+interface RepoGroup {
+  repo: string
+  protocol: "https" | "ssh"
+  skills: ManagedSkill[]
+}
+
+function groupByRepo(skills: ManagedSkill[]): RepoGroup[] {
+  const groups = new Map<string, RepoGroup>()
+
+  for (const skill of skills) {
+    if (!skill.installSource) continue
+    // Skip local skills - they're symlinked and always up to date
+    if (skill.installSource.protocol === "local") continue
+
+    const key = `${skill.installSource.protocol}:${skill.installSource.repo}`
+    if (!groups.has(key)) {
+      groups.set(key, {
+        repo: skill.installSource.repo,
+        protocol: skill.installSource.protocol as "https" | "ssh",
+        skills: []
+      })
+    }
+    groups.get(key)!.skills.push(skill)
+  }
+
+  return Array.from(groups.values())
+}
+
+export interface UpdateOptions {
+  skillsDir: string
+  registryPath: string
+  onConfirm: (updates: Array<{ name: string; hasChanges: boolean }>) => Promise<string[]>
+}
+
+export async function runUpdate(options: UpdateOptions): Promise<void> {
+  const skillsStore = new SkillsStore(options.skillsDir, options.registryPath)
+  const registryStore = new RegistryStore(options.registryPath)
+  const registry = await registryStore.load()
+
+  // Find skills with installSource (excluding local symlinked skills)
+  const allSkillsWithSource = Object.values(registry.skills).filter(s => s.installSource)
+  const localSkills = allSkillsWithSource.filter(s => s.installSource?.protocol === "local")
+  const remoteSkills = allSkillsWithSource.filter(s => s.installSource?.protocol !== "local")
+
+  if (allSkillsWithSource.length === 0) {
+    console.log("No updatable skills found. Skills need installSource to be updated.")
+    return
+  }
+
+  if (localSkills.length > 0) {
+    console.log(`Skipping ${localSkills.length} local symlinked skills (always up to date)`)
+  }
+
+  if (remoteSkills.length === 0) {
+    console.log("No remote skills to update.")
+    return
+  }
+
+  console.log(`Found ${remoteSkills.length} remote skills to check`)
+
+  // Group by repo
+  const repoGroups = groupByRepo(remoteSkills)
+  const allUpdates: SkillUpdate[] = []
+
+  for (const group of repoGroups) {
+    console.log(`\nChecking ${group.repo}...`)
+
+    // Clone the repo
+    let url: string
+    if (group.repo.includes("://") || group.repo.startsWith("git@")) {
+      url = group.repo
+    } else if (group.protocol === "ssh") {
+      url = `git@github.com:${group.repo}.git`
+    } else {
+      url = `https://github.com/${group.repo}`
+    }
+
+    const tempDir = join(tmpdir(), `simba-update-${Date.now()}`)
+    await mkdir(tempDir, { recursive: true })
+
+    try {
+      const git = simpleGit()
+      await git.clone(url, tempDir, ["--depth", "1"])
+
+      // Discover skills in the cloned repo
+      const discovered = await discoverSkills(tempDir)
+      const discoveredByPath = new Map(
+        discovered.map(s => [s.relativePath, s])
+      )
+
+      // Check each skill for updates
+      for (const skill of group.skills) {
+        const skillPath = skill.installSource!.skillPath
+        const remote = discoveredByPath.get(skillPath)
+
+        if (!remote) {
+          console.log(`  ⚠ ${skill.name}: skill path not found in repo (${skillPath})`)
+          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")
+
+        if (comparison.identical) {
+          console.log(`  ✓ ${skill.name}: up to date`)
+        } else {
+          console.log(`  ↑ ${skill.name}: update available`)
+          allUpdates.push({
+            skill,
+            newPath: remote.path,
+            newContent,
+            existingContent
+          })
+        }
+      }
+    } finally {
+      await rm(tempDir, { recursive: true, force: true })
+    }
+  }
+
+  if (allUpdates.length === 0) {
+    console.log("\nAll skills are up to date!")
+    return
+  }
+
+  console.log(`\n${allUpdates.length} updates available:`)
+
+  // Show updates and prompt for selection
+  const updateInfo = allUpdates.map(u => ({
+    name: u.skill.name,
+    hasChanges: true
+  }))
+
+  const selectedNames = await options.onConfirm(updateInfo)
+
+  if (selectedNames.length === 0) {
+    console.log("No updates selected.")
+    return
+  }
+
+  // Apply selected updates
+  for (const name of selectedNames) {
+    const update = allUpdates.find(u => u.skill.name === name)!
+    const existingParsed = matter(update.existingContent)
+    const newParsed = matter(update.newContent)
+
+    const existingVersion = existingParsed.data.version as string | undefined
+    const newVersion = newParsed.data.version as string | undefined
+
+    if (existingVersion && newVersion) {
+      console.log(`\n${name}: v${existingVersion} → v${newVersion}`)
+    } else {
+      console.log(`\n${name}: changes detected`)
+    }
+
+    const comparison = compareFiles(update.existingContent, update.newContent, "SKILL.md")
+    if (comparison.diff) {
+      renderDiff(comparison.diff, "current", "new")
+    }
+
+    // Re-clone to get the files (since we deleted tempDir)
+    const source = update.skill.installSource!
+    let url: string
+    if (source.repo.includes("://") || source.repo.startsWith("git@")) {
+      url = source.repo
+    } else if (source.protocol === "ssh") {
+      url = `git@github.com:${source.repo}.git`
+    } else {
+      url = `https://github.com/${source.repo}`
+    }
+
+    const tempDir = join(tmpdir(), `simba-update-apply-${Date.now()}`)
+    await mkdir(tempDir, { recursive: true })
+
+    try {
+      const git = simpleGit()
+      await git.clone(url, tempDir, ["--depth", "1"])
+
+      const discovered = await discoverSkills(tempDir)
+      const remote = discovered.find(s => s.relativePath === source.skillPath)
+
+      if (!remote) {
+        console.log(`  Error: Could not find skill at ${source.skillPath}`)
+        continue
+      }
+
+      // Remove old and add new
+      await rm(join(options.skillsDir, name), { recursive: true })
+      await skillsStore.addSkill(name, remote.path)
+
+      registry.skills[name].installedAt = new Date().toISOString()
+      console.log(`  Updated: ${name}`)
+    } finally {
+      await rm(tempDir, { recursive: true, force: true })
+    }
+  }
+
+  await registryStore.save(registry)
+  console.log("\nUpdate complete!")
+}
+
+export default defineCommand({
+  meta: { name: "update", description: "Update installed skills from their sources" },
+  args: {},
+  async run() {
+    await runUpdate({
+      skillsDir: getSkillsDir(),
+      registryPath: getRegistryPath(),
+      onConfirm: async (updates) => {
+        const result = await p.multiselect({
+          message: "Select skills to update:",
+          options: updates.map(u => ({
+            value: u.name,
+            label: u.name,
+          })),
+          initialValues: updates.map(u => u.name), // Select all by default
+        })
+
+        if (p.isCancel(result)) {
+          process.exit(0)
+        }
+
+        return result as string[]
+      },
+    })
+  },
+})

package/src/core/agent-registry.ts

@@ -0,0 +1,105 @@
+import { access, readdir, mkdir, cp, rm } from "node:fs/promises"
+import { join, dirname } from "node:path"
+import { expandPath } from "../utils/paths"
+import { hashTree } from "../utils/hash"
+import type { Agent, SkillInfo } from "./types"
+
+export class AgentRegistry {
+  constructor(private agents: Record<string, Agent>) {}
+
+  async detectAgents(): Promise<Record<string, Agent>> {
+    const results: Record<string, Agent> = {}
+
+    for (const [id, agent] of Object.entries(this.agents)) {
+      const globalPath = expandPath(agent.globalPath)
+      const parentDir = dirname(globalPath)
+
+      let detected = false
+      try {
+        await access(parentDir)
+        detected = true
+      } catch {
+        detected = false
+      }
+
+      results[id] = { ...agent, detected }
+    }
+
+    return results
+  }
+
+  async listSkills(agentId: string): Promise<SkillInfo[]> {
+    const agent = this.agents[agentId]
+    if (!agent) throw new Error(`Unknown agent: ${agentId}`)
+
+    const skillsPath = expandPath(agent.globalPath)
+    const skills: SkillInfo[] = []
+
+    try {
+      const entries = await readdir(skillsPath, { withFileTypes: true })
+
+      for (const entry of entries) {
+        if (!entry.isDirectory()) continue
+
+        const skillPath = join(skillsPath, entry.name)
+        const skillMdPath = join(skillPath, "SKILL.md")
+
+        try {
+          await access(skillMdPath)
+        } catch {
+          continue // Skip directories without SKILL.md
+        }
+
+        const { treeHash, files } = await hashTree(skillPath)
+
+        skills.push({
+          name: entry.name,
+          treeHash,
+          files,
+          origin: agentId,
+          lastSeen: new Date(),
+          agents: [agentId],
+        })
+      }
+    } catch (err) {
+      if ((err as NodeJS.ErrnoException).code !== "ENOENT") {
+        throw err
+      }
+    }
+
+    return skills
+  }
+
+  async copySkill(
+    skillName: string,
+    fromAgent: string,
+    toAgent: string
+  ): Promise<void> {
+    const from = this.agents[fromAgent]
+    const to = this.agents[toAgent]
+
+    if (!from || !to) {
+      throw new Error(`Unknown agent: ${fromAgent} or ${toAgent}`)
+    }
+
+    const sourcePath = join(expandPath(from.globalPath), skillName)
+    const destPath = join(expandPath(to.globalPath), skillName)
+
+    await mkdir(dirname(destPath), { recursive: true })
+    await cp(sourcePath, destPath, { recursive: true })
+  }
+
+  async deleteSkill(skillName: string, agentId: string): Promise<void> {
+    const agent = this.agents[agentId]
+    if (!agent) throw new Error(`Unknown agent: ${agentId}`)
+
+    const skillPath = join(expandPath(agent.globalPath), skillName)
+    await rm(skillPath, { recursive: true })
+  }
+
+  getSkillPath(skillName: string, agentId: string): string {
+    const agent = this.agents[agentId]
+    if (!agent) throw new Error(`Unknown agent: ${agentId}`)
+    return join(expandPath(agent.globalPath), skillName)
+  }
+}

package/src/core/config-store.ts

@@ -0,0 +1,89 @@
+import { parse, stringify } from "smol-toml";
+import { readFile, writeFile, mkdir } from "node:fs/promises";
+import { dirname } from "node:path";
+import type { Config, Agent } from "./types";
+
+// Add new agents here: [id, name, shortName, globalPath, projectPath]
+const AGENT_DEFINITIONS: [string, string, string, string, string][] = [
+    ["claude", "Claude Code", "Claude", "~/.claude/skills", ".claude/skills"],
+    ["cursor", "Cursor", "Cursor", "~/.cursor/skills", ".cursor/skills"],
+    ["codex", "Codex", "Codex", "~/.codex/skills", ".codex/skills"],
+    ["copilot", "GitHub Copilot", "Copilot", "~/.copilot/skills", ".github/skills"],
+    ["gemini", "Gemini CLI", "Gemini", "~/.gemini/skills", ".gemini/skills"],
+    ["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"],
+    ["kilo", "Kilo Code", "Kilo", "~/.kilocode/skills", ".kilocode/skills"],
+    ["roo", "Roo Code", "Roo", "~/.roo/skills", ".roo/skills"],
+    ["antigravity", "Antigravity", "Antigrav", "~/.gemini/antigravity/skills", ".agent/skills"],
+    ["clawdbot", "Clawdbot", "Clawdbot", "~/.clawdbot/skills", "skills"],
+    ["droid", "Droid", "Droid", "~/.factory/skills", ".factory/skills"],
+];
+
+const DEFAULT_AGENTS: Record<string, Agent> = Object.fromEntries(
+    AGENT_DEFINITIONS.map(([id, name, shortName, globalPath, projectPath]) => [
+        id,
+        { id, name, shortName, globalPath, projectPath, detected: false },
+    ]),
+);
+
+function createDefaultConfig(): Config {
+    return {
+        agents: { ...DEFAULT_AGENTS },
+        sync: {
+            strategy: "union",
+            sourceAgent: "",
+        },
+        snapshots: {
+            maxCount: 10,
+            autoSnapshot: true,
+        },
+        skills: {},
+    };
+}
+
+export class ConfigStore {
+    constructor(private configPath: string) {}
+
+    async load(): Promise<Config> {
+        try {
+            const content = await readFile(this.configPath, "utf-8");
+            const parsed = parse(content) as unknown as Config;
+            return this.mergeWithDefaults(parsed);
+        } catch (err) {
+            if ((err as NodeJS.ErrnoException).code === "ENOENT") {
+                return createDefaultConfig();
+            }
+            throw err;
+        }
+    }
+
+    async save(config: Config): Promise<void> {
+        await mkdir(dirname(this.configPath), { recursive: true });
+        const toml = stringify(config as unknown as Record<string, unknown>);
+        await writeFile(this.configPath, toml);
+    }
+
+    private mergeWithDefaults(parsed: Partial<Config>): Config {
+        const defaults = createDefaultConfig();
+
+        // Merge agents and ensure shortName exists for each
+        const mergedAgents = { ...defaults.agents };
+        for (const [id, agent] of Object.entries(parsed.agents ?? {})) {
+            mergedAgents[id] = {
+                ...defaults.agents[id],
+                ...agent,
+                // Ensure shortName exists, fallback to first word of name or id
+                shortName: agent.shortName ?? defaults.agents[id]?.shortName ?? agent.name?.split(" ")[0] ?? id,
+            };
+        }
+
+        return {
+            agents: mergedAgents,
+            sync: { ...defaults.sync, ...parsed.sync },
+            snapshots: { ...defaults.snapshots, ...parsed.snapshots },
+            skills: parsed.skills ?? {},
+        };
+    }
+}

package/src/core/registry-store.ts

@@ -0,0 +1,28 @@
+import { readFile, writeFile, mkdir } from "node:fs/promises"
+import { dirname } from "node:path"
+import type { Registry } from "./types"
+
+function createEmptyRegistry(): Registry {
+  return { version: 1, skills: {} }
+}
+
+export class RegistryStore {
+  constructor(private registryPath: string) {}
+
+  async load(): Promise<Registry> {
+    try {
+      const content = await readFile(this.registryPath, "utf-8")
+      return JSON.parse(content) as Registry
+    } catch (err) {
+      if ((err as NodeJS.ErrnoException).code === "ENOENT") {
+        return createEmptyRegistry()
+      }
+      throw err
+    }
+  }
+
+  async save(registry: Registry): Promise<void> {
+    await mkdir(dirname(this.registryPath), { recursive: true })
+    await writeFile(this.registryPath, JSON.stringify(registry, null, 2))
+  }
+}

package/src/core/skill-manager.ts

@@ -0,0 +1,99 @@
+import type { Agent, SkillMatrix, SkillStatus } from "./types"
+import type { AgentRegistry } from "./agent-registry"
+
+export class SkillManager {
+  constructor(
+    private registry: AgentRegistry,
+    private agents: Record<string, Agent>
+  ) {}
+
+  async buildMatrix(): Promise<SkillMatrix[]> {
+    const detectedAgents = Object.entries(this.agents).filter(
+      ([_, agent]) => agent.detected
+    )
+
+    // Collect all skills from all agents
+    const skillMap = new Map<
+      string,
+      Map<string, { present: boolean; hash: string | null }>
+    >()
+
+    for (const [agentId] of detectedAgents) {
+      const skills = await this.registry.listSkills(agentId)
+
+      for (const skill of skills) {
+        if (!skillMap.has(skill.name)) {
+          skillMap.set(skill.name, new Map())
+        }
+        skillMap.get(skill.name)!.set(agentId, {
+          present: true,
+          hash: skill.treeHash,
+        })
+      }
+    }
+
+    // Build matrix with status
+    const matrix: SkillMatrix[] = []
+
+    for (const [skillName, agentHashes] of skillMap) {
+      const agents: Record<string, { present: boolean; hash: string | null }> =
+        {}
+
+      // Initialize all agents as not present
+      for (const [agentId] of detectedAgents) {
+        agents[agentId] = agentHashes.get(agentId) ?? {
+          present: false,
+          hash: null,
+        }
+      }
+
+      const status = this.computeStatus(agentHashes)
+
+      matrix.push({ skillName, agents, status })
+    }
+
+    return matrix.sort((a, b) => a.skillName.localeCompare(b.skillName))
+  }
+
+  private computeStatus(
+    agentHashes: Map<string, { present: boolean; hash: string | null }>
+  ): SkillStatus {
+    const presentAgents = Array.from(agentHashes.entries()).filter(
+      ([_, v]) => v.present
+    )
+
+    if (presentAgents.length === 0) {
+      return "missing"
+    }
+
+    if (presentAgents.length === 1) {
+      return "unique"
+    }
+
+    const hashes = new Set(presentAgents.map(([_, v]) => v.hash))
+    return hashes.size === 1 ? "synced" : "conflict"
+  }
+
+  async syncUnique(skillName: string, sourceAgent: string): Promise<string[]> {
+    const targetAgents = Object.entries(this.agents)
+      .filter(([id, agent]) => agent.detected && id !== sourceAgent)
+      .map(([id]) => id)
+
+    for (const targetAgent of targetAgents) {
+      await this.registry.copySkill(skillName, sourceAgent, targetAgent)
+    }
+
+    return targetAgents
+  }
+
+  async resolveConflict(
+    skillName: string,
+    winnerAgent: string,
+    loserAgents: string[]
+  ): Promise<void> {
+    for (const loserAgent of loserAgents) {
+      await this.registry.deleteSkill(skillName, loserAgent)
+      await this.registry.copySkill(skillName, winnerAgent, loserAgent)
+    }
+  }
+}

package/src/core/skills-store.ts

@@ -0,0 +1,79 @@
+import { readdir, access, mkdir, cp, rm } from "node:fs/promises"
+import { join } from "node:path"
+import { createSymlink, removeSymlink } from "../utils/symlinks"
+import type { SkillAssignment } from "./types"
+
+export class SkillsStore {
+  constructor(
+    private skillsDir: string,
+    private registryPath: string
+  ) {}
+
+  async ensureDir(): Promise<void> {
+    await mkdir(this.skillsDir, { recursive: true })
+  }
+
+  async listSkills(): Promise<string[]> {
+    try {
+      const entries = await readdir(this.skillsDir, { withFileTypes: true })
+      return entries.filter(e => e.isDirectory()).map(e => e.name)
+    } catch (err) {
+      if ((err as NodeJS.ErrnoException).code === "ENOENT") {
+        return []
+      }
+      throw err
+    }
+  }
+
+  async hasSkill(name: string): Promise<boolean> {
+    try {
+      await access(join(this.skillsDir, name))
+      return true
+    } catch {
+      return false
+    }
+  }
+
+  async addSkill(name: string, sourcePath: string): Promise<void> {
+    await this.ensureDir()
+    const destPath = join(this.skillsDir, name)
+    await cp(sourcePath, destPath, { recursive: true })
+  }
+
+  async linkSkill(name: string, sourcePath: string): Promise<void> {
+    await this.ensureDir()
+    const destPath = join(this.skillsDir, name)
+    await createSymlink(sourcePath, destPath)
+  }
+
+  async removeSkill(name: string): Promise<void> {
+    const skillPath = join(this.skillsDir, name)
+    await rm(skillPath, { recursive: true })
+  }
+
+  async assignSkill(
+    name: string,
+    agentSkillsDir: string,
+    assignment: SkillAssignment
+  ): Promise<void> {
+    const sourcePath = join(this.skillsDir, name)
+
+    if (assignment.type === "directory") {
+      const targetPath = join(agentSkillsDir, name)
+      await createSymlink(sourcePath, targetPath)
+    } else {
+      const sourceFile = join(sourcePath, assignment.target!)
+      const targetPath = join(agentSkillsDir, `${name}.${assignment.target!.split(".").pop()}`)
+      await createSymlink(sourceFile, targetPath)
+    }
+  }
+
+  async unassignSkill(name: string, agentSkillsDir: string): Promise<void> {
+    const targetPath = join(agentSkillsDir, name)
+    await removeSymlink(targetPath)
+  }
+
+  getSkillPath(name: string): string {
+    return join(this.skillsDir, name)
+  }
+}