simba-skills 0.1.2

package/src/commands/restore.ts

@@ -0,0 +1,175 @@
+import { defineCommand } from "citty"
+import { ConfigStore } from "../core/config-store"
+import { AgentRegistry } from "../core/agent-registry"
+import { SnapshotManager } from "../core/snapshot"
+import { getConfigPath, getSnapshotsDir, expandPath } from "../utils/paths"
+import { selectFromList, selectAgent, inputText } from "../utils/prompts"
+import { mkdir, readFile } from "node:fs/promises"
+import { join, dirname } from "node:path"
+import * as tar from "tar"
+
+export default defineCommand({
+  meta: {
+    name: "restore",
+    description: "Restore skills from backup",
+  },
+  args: {
+    path: {
+      type: "positional",
+      description: "Backup path (.tar.gz)",
+    },
+    to: {
+      type: "string",
+      description: "Restore to specific agent only",
+    },
+    snapshot: {
+      type: "string",
+      description: "Restore from snapshot ID instead of backup file",
+    },
+    dryRun: {
+      type: "boolean",
+      alias: "n",
+      description: "Preview changes without applying",
+      default: false,
+    },
+  },
+  async run({ args }) {
+    const configStore = new ConfigStore(getConfigPath())
+    const config = await configStore.load()
+
+    let snapshotId = args.snapshot
+    let backupPath = args.path
+
+    // Interactive mode if no path or snapshot provided
+    if (!backupPath && !snapshotId) {
+      const mode = await selectFromList("Restore from:", [
+        { value: "snapshot", label: "Snapshot", hint: "restore from auto-saved snapshot" },
+        { value: "backup", label: "Backup file", hint: "restore from .tar.gz archive" },
+      ])
+
+      if (mode === "snapshot") {
+        const snapshots = new SnapshotManager(getSnapshotsDir(), config.snapshots.maxCount)
+        const list = await snapshots.listSnapshots()
+
+        if (list.length === 0) {
+          console.log("No snapshots available.")
+          return
+        }
+
+        snapshotId = await selectFromList(
+          "Select snapshot:",
+          list.map((s) => ({
+            value: s.id,
+            label: s.id,
+            hint: `${s.reason} (${s.skills.length} skills)`,
+          }))
+        )
+      } else {
+        backupPath = await inputText("Backup file path:", { placeholder: "./backup.tar.gz" })
+      }
+    }
+
+    // Handle snapshot restore
+    if (snapshotId) {
+      const snapshots = new SnapshotManager(
+        getSnapshotsDir(),
+        config.snapshots.maxCount
+      )
+      const list = await snapshots.listSnapshots()
+      const snapshot = list.find((s) => s.id === snapshotId)
+
+      if (!snapshot) {
+        console.error(`Snapshot not found: ${snapshotId}`)
+        process.exit(1)
+      }
+
+      console.log(`\nRestoring from snapshot: ${snapshot.id}`)
+      console.log(`Skills: ${snapshot.skills.join(", ")}`)
+
+      if (args.dryRun) {
+        console.log("\n(dry run - no changes made)")
+        return
+      }
+
+      // Restore to all detected agents or specific one
+      const targetAgents = args.to
+        ? [args.to]
+        : Object.entries(config.agents)
+            .filter(([_, a]) => a.detected)
+            .map(([id]) => id)
+
+      for (const agentId of targetAgents) {
+        const agent = config.agents[agentId]
+        if (!agent) continue
+        await snapshots.restore(snapshotId, expandPath(agent.globalPath))
+        console.log(`Restored to ${agent.name}`)
+      }
+
+      console.log("\nRestore complete!")
+      return
+    }
+
+    // Handle backup file restore
+    if (!backupPath) {
+      console.error("No backup path provided.")
+      process.exit(1)
+    }
+
+    const tempDir = join(dirname(backupPath), `.simba-restore-${Date.now()}`)
+    await mkdir(tempDir, { recursive: true })
+
+    // Extract backup
+    await tar.extract({
+      file: backupPath,
+      cwd: tempDir,
+    })
+
+    // Read manifest
+    const manifest = JSON.parse(
+      await readFile(join(tempDir, "manifest.json"), "utf-8")
+    )
+
+    console.log(`\nRestoring from backup: ${backupPath}`)
+    console.log(`Created: ${manifest.created}`)
+    console.log(`Skills: ${Object.keys(manifest.skills).length}`)
+
+    if (args.dryRun) {
+      console.log("\nWould restore:")
+      for (const skillName of Object.keys(manifest.skills)) {
+        console.log(`  ${skillName}`)
+      }
+      console.log("\n(dry run - no changes made)")
+      await Bun.$`rm -rf ${tempDir}`
+      return
+    }
+
+    // Determine target agents
+    const targetAgents = args.to
+      ? [args.to]
+      : Object.entries(config.agents)
+          .filter(([_, a]) => a.detected)
+          .map(([id]) => id)
+
+    // Copy skills to targets
+    for (const agentId of targetAgents) {
+      const agent = config.agents[agentId]
+      if (!agent) continue
+
+      const skillsPath = expandPath(agent.globalPath)
+      await mkdir(skillsPath, { recursive: true })
+
+      for (const skillName of Object.keys(manifest.skills)) {
+        const sourcePath = join(tempDir, "skills", skillName)
+        const destPath = join(skillsPath, skillName)
+        await Bun.$`cp -r ${sourcePath} ${destPath}`
+      }
+
+      console.log(`Restored to ${agent.name}`)
+    }
+
+    // Cleanup temp
+    await Bun.$`rm -rf ${tempDir}`
+
+    console.log("\nRestore complete!")
+  },
+})

package/src/commands/snapshots.ts

@@ -0,0 +1,39 @@
+import { defineCommand } from "citty"
+import { ConfigStore } from "../core/config-store"
+import { SnapshotManager } from "../core/snapshot"
+import { getConfigPath, getSnapshotsDir } from "../utils/paths"
+
+export default defineCommand({
+  meta: {
+    name: "snapshots",
+    description: "List available snapshots",
+  },
+  async run() {
+    const configStore = new ConfigStore(getConfigPath())
+    const config = await configStore.load()
+
+    const snapshots = new SnapshotManager(
+      getSnapshotsDir(),
+      config.snapshots.maxCount
+    )
+
+    const list = await snapshots.listSnapshots()
+
+    if (list.length === 0) {
+      console.log("No snapshots available.")
+      return
+    }
+
+    console.log("\nAvailable snapshots:\n")
+
+    for (const snapshot of list) {
+      console.log(`  ${snapshot.id}`)
+      console.log(`    Reason: ${snapshot.reason}`)
+      console.log(`    Skills: ${snapshot.skills.length}`)
+      console.log("")
+    }
+
+    console.log(`Total: ${list.length} snapshots`)
+    console.log(`\nUse 'simba restore --snapshot <id>' to restore`)
+  },
+})

package/src/commands/status.ts

@@ -0,0 +1,70 @@
+import { defineCommand } from "citty"
+import { ConfigStore } from "../core/config-store"
+import { AgentRegistry } from "../core/agent-registry"
+import { SkillManager } from "../core/skill-manager"
+import { getConfigPath } from "../utils/paths"
+
+export default defineCommand({
+  meta: {
+    name: "status",
+    description: "Show skill matrix across agents",
+  },
+  args: {
+    agent: {
+      type: "string",
+      description: "Filter to specific agent",
+    },
+  },
+  async run({ args }) {
+    const configStore = new ConfigStore(getConfigPath())
+    const config = await configStore.load()
+
+    const registry = new AgentRegistry(config.agents)
+    const manager = new SkillManager(registry, config.agents)
+
+    const matrix = await manager.buildMatrix()
+
+    // Get detected agents
+    const detectedAgents = Object.entries(config.agents)
+      .filter(([_, a]) => a.detected)
+      .filter(([id]) => !args.agent || id === args.agent)
+
+    if (detectedAgents.length === 0) {
+      console.log("No agents detected. Run 'simba detect' first.")
+      return
+    }
+
+    // Print header
+    const agentNames = detectedAgents.map(([_, a]) => a.shortName.padEnd(8))
+    console.log(`\n${"Skill".padEnd(24)} ${agentNames.join(" ")}`)
+    console.log("─".repeat(24 + agentNames.length * 9))
+
+    // Print matrix
+    const statusSymbols = {
+      synced: "✓",
+      conflict: "⚠",
+      unique: "●",
+      missing: "─",
+    }
+
+    for (const row of matrix) {
+      const cells = detectedAgents.map(([id]) => {
+        const cell = row.agents[id]
+        if (!cell?.present) return "─".padStart(4).padEnd(8)
+        if (row.status === "conflict") return "⚠".padStart(4).padEnd(8)
+        return "✓".padStart(4).padEnd(8)
+      })
+
+      const skillName = row.skillName.slice(0, 23).padEnd(24)
+      console.log(`${skillName} ${cells.join(" ")}`)
+    }
+
+    // Summary
+    const synced = matrix.filter((m) => m.status === "synced").length
+    const conflicts = matrix.filter((m) => m.status === "conflict").length
+    const unique = matrix.filter((m) => m.status === "unique").length
+
+    console.log("\n" + "─".repeat(24 + agentNames.length * 9))
+    console.log(`✓ synced: ${synced}  ⚠ conflict: ${conflicts}  ● unique: ${unique}`)
+  },
+})

package/src/commands/sync.ts

@@ -0,0 +1,108 @@
+import { defineCommand } from "citty"
+import { ConfigStore } from "../core/config-store"
+import { AgentRegistry } from "../core/agent-registry"
+import { SkillManager } from "../core/skill-manager"
+import { SnapshotManager } from "../core/snapshot"
+import { getConfigPath, getSnapshotsDir } from "../utils/paths"
+import * as readline from "node:readline"
+
+export default defineCommand({
+  meta: {
+    name: "sync",
+    description: "Sync skills across agents (union merge)",
+  },
+  args: {
+    source: {
+      type: "string",
+      description: "Source of truth agent (one-way sync)",
+    },
+    dryRun: {
+      type: "boolean",
+      alias: "n",
+      description: "Preview changes without applying",
+      default: false,
+    },
+  },
+  async run({ args }) {
+    const configStore = new ConfigStore(getConfigPath())
+    const config = await configStore.load()
+
+    const registry = new AgentRegistry(config.agents)
+    const manager = new SkillManager(registry, config.agents)
+    const snapshots = new SnapshotManager(
+      getSnapshotsDir(),
+      config.snapshots.maxCount
+    )
+
+    const matrix = await manager.buildMatrix()
+
+    const unique = matrix.filter((m) => m.status === "unique")
+    const conflicts = matrix.filter((m) => m.status === "conflict")
+
+    if (unique.length === 0 && conflicts.length === 0) {
+      console.log("All skills are synced!")
+      return
+    }
+
+    // Show what will happen
+    if (unique.length > 0) {
+      console.log("\nWill copy:")
+      for (const skill of unique) {
+        const source = Object.entries(skill.agents).find(([_, v]) => v.present)?.[0]
+        const targets = Object.entries(skill.agents)
+          .filter(([_, v]) => !v.present)
+          .map(([id]) => id)
+        console.log(`  ${skill.skillName}  →  ${targets.join(", ")}`)
+      }
+    }
+
+    if (conflicts.length > 0 && !args.source) {
+      console.log("\nConflicts (resolve manually):")
+      for (const skill of conflicts) {
+        const agents = Object.entries(skill.agents)
+          .filter(([_, v]) => v.present)
+          .map(([id]) => id)
+        console.log(`  ${skill.skillName}: ${agents.join(" ≠ ")}`)
+      }
+    }
+
+    if (args.dryRun) {
+      console.log("\n(dry run - no changes made)")
+      return
+    }
+
+    // Create snapshot before changes
+    if (config.snapshots.autoSnapshot && (unique.length > 0 || conflicts.length > 0)) {
+      const skillPaths = [...unique, ...conflicts].flatMap((skill) =>
+        Object.entries(skill.agents)
+          .filter(([_, v]) => v.present)
+          .map(([agentId]) => registry.getSkillPath(skill.skillName, agentId))
+      )
+      await snapshots.createSnapshot(skillPaths, "pre-sync")
+      console.log("\nSnapshot created.")
+    }
+
+    // Sync unique skills
+    for (const skill of unique) {
+      const source = Object.entries(skill.agents).find(([_, v]) => v.present)?.[0]
+      if (!source) continue
+
+      const synced = await manager.syncUnique(skill.skillName, source)
+      console.log(`Synced ${skill.skillName} to ${synced.join(", ")}`)
+    }
+
+    // Handle conflicts with --source flag
+    if (args.source && conflicts.length > 0) {
+      for (const skill of conflicts) {
+        const losers = Object.entries(skill.agents)
+          .filter(([id, v]) => v.present && id !== args.source)
+          .map(([id]) => id)
+
+        await manager.resolveConflict(skill.skillName, args.source, losers)
+        console.log(`Resolved ${skill.skillName} using ${args.source}`)
+      }
+    }
+
+    console.log("\nSync complete!")
+  },
+})

package/src/commands/unassign.ts

@@ -0,0 +1,68 @@
+import { defineCommand } from "citty"
+import { RegistryStore } from "../core/registry-store"
+import { SkillsStore } from "../core/skills-store"
+import { ConfigStore } from "../core/config-store"
+import { getSkillsDir, getRegistryPath, getConfigPath, expandPath } from "../utils/paths"
+
+export interface UnassignOptions {
+  skill: string
+  agents: string[]
+  skillsDir: string
+  registryPath: string
+  agentPaths: Record<string, string>
+}
+
+export async function runUnassign(options: UnassignOptions): Promise<void> {
+  const skillsStore = new SkillsStore(options.skillsDir, options.registryPath)
+  const registryStore = new RegistryStore(options.registryPath)
+  const registry = await registryStore.load()
+
+  const skill = registry.skills[options.skill]
+  if (!skill) {
+    console.error(`Skill not found: ${options.skill}`)
+    process.exit(1)
+  }
+
+  for (const agentId of options.agents) {
+    const agentPath = options.agentPaths[agentId]
+    if (!agentPath) {
+      console.error(`Unknown agent: ${agentId}`)
+      continue
+    }
+
+    await skillsStore.unassignSkill(options.skill, agentPath)
+    delete skill.assignments[agentId]
+    console.log(`Unassigned ${options.skill} from ${agentId}`)
+  }
+
+  await registryStore.save(registry)
+}
+
+export default defineCommand({
+  meta: { name: "unassign", description: "Remove a skill from agents" },
+  args: {
+    skill: { type: "positional", description: "Skill name", required: true },
+    agents: { type: "positional", description: "Agent IDs (comma-separated)", required: true },
+  },
+  async run({ args }) {
+    const configStore = new ConfigStore(getConfigPath())
+    const config = await configStore.load()
+
+    const agentPaths: Record<string, string> = {}
+    for (const [id, agent] of Object.entries(config.agents)) {
+      if (agent.detected) {
+        agentPaths[id] = expandPath(agent.globalPath)
+      }
+    }
+
+    const agents = (args.agents as string).split(",").map(a => a.trim())
+
+    await runUnassign({
+      skill: args.skill,
+      agents,
+      skillsDir: getSkillsDir(),
+      registryPath: getRegistryPath(),
+      agentPaths,
+    })
+  },
+})

package/src/commands/undo.ts

@@ -0,0 +1,57 @@
+import { defineCommand } from "citty"
+import { ConfigStore } from "../core/config-store"
+import { SnapshotManager } from "../core/snapshot"
+import { getConfigPath, getSnapshotsDir, expandPath } from "../utils/paths"
+
+export default defineCommand({
+  meta: {
+    name: "undo",
+    description: "Restore from most recent snapshot",
+  },
+  args: {
+    dryRun: {
+      type: "boolean",
+      alias: "n",
+      description: "Preview changes without applying",
+      default: false,
+    },
+  },
+  async run({ args }) {
+    const configStore = new ConfigStore(getConfigPath())
+    const config = await configStore.load()
+
+    const snapshots = new SnapshotManager(
+      getSnapshotsDir(),
+      config.snapshots.maxCount
+    )
+
+    const latest = await snapshots.getLatestSnapshot()
+
+    if (!latest) {
+      console.log("No snapshots available.")
+      return
+    }
+
+    console.log(`\nLatest snapshot: ${latest.id}`)
+    console.log(`Reason: ${latest.reason}`)
+    console.log(`Created: ${latest.created}`)
+    console.log(`Skills: ${latest.skills.join(", ")}`)
+
+    if (args.dryRun) {
+      console.log("\n(dry run - no changes made)")
+      return
+    }
+
+    // Restore to all detected agents
+    const targetAgents = Object.entries(config.agents)
+      .filter(([_, a]) => a.detected)
+      .map(([id, a]) => ({ id, path: expandPath(a.globalPath) }))
+
+    for (const { id, path } of targetAgents) {
+      await snapshots.restore(latest.id, path)
+      console.log(`Restored to ${config.agents[id].name}`)
+    }
+
+    console.log("\nUndo complete!")
+  },
+})

package/src/commands/uninstall.ts

@@ -0,0 +1,134 @@
+import { defineCommand } from "citty"
+import { rm } from "node:fs/promises"
+import { join } from "node:path"
+import * as p from "@clack/prompts"
+import { RegistryStore } from "../core/registry-store"
+import { SkillsStore } from "../core/skills-store"
+import { ConfigStore } from "../core/config-store"
+import { AgentRegistry } from "../core/agent-registry"
+import { getSkillsDir, getRegistryPath, getConfigPath, expandPath } from "../utils/paths"
+
+export interface UninstallOptions {
+  skills: string[]
+  skillsDir: string
+  registryPath: string
+  agentPaths: Record<string, string>
+  deleteFiles: boolean
+}
+
+export async function runUninstall(options: UninstallOptions): Promise<void> {
+  const skillsStore = new SkillsStore(options.skillsDir, options.registryPath)
+  const registryStore = new RegistryStore(options.registryPath)
+  const registry = await registryStore.load()
+
+  for (const name of options.skills) {
+    const skill = registry.skills[name]
+    if (!skill) {
+      console.log(`  Skill not found: ${name}`)
+      continue
+    }
+
+    // Remove symlinks from all assigned agents
+    for (const agentId of Object.keys(skill.assignments)) {
+      const agentPath = options.agentPaths[agentId]
+      if (agentPath) {
+        try {
+          await rm(join(agentPath, name), { recursive: true, force: true })
+          console.log(`  Removed from ${agentId}`)
+        } catch {
+          // Ignore errors if symlink doesn't exist
+        }
+      }
+    }
+
+    // Remove from store if requested
+    if (options.deleteFiles) {
+      await rm(join(options.skillsDir, name), { recursive: true, force: true })
+      console.log(`  Deleted files: ${name}`)
+    }
+
+    // Remove from registry
+    delete registry.skills[name]
+
+    console.log(`  Uninstalled: ${name}`)
+  }
+
+  await registryStore.save(registry)
+  console.log("\nUninstall complete!")
+}
+
+export default defineCommand({
+  meta: { name: "uninstall", description: "Remove a skill from Simba's store" },
+  args: {
+    skill: { type: "positional", description: "Skill name to uninstall", required: false },
+  },
+  async run({ args }) {
+    const registryStore = new RegistryStore(getRegistryPath())
+    const registry = await registryStore.load()
+
+    const configStore = new ConfigStore(getConfigPath())
+    const config = await configStore.load()
+
+    // Get agent paths
+    const agentRegistry = new AgentRegistry(config.agents)
+    const detected = await agentRegistry.detectAgents()
+
+    const agentPaths: Record<string, string> = {}
+    for (const [id, agent] of Object.entries(detected)) {
+      agentPaths[id] = expandPath(agent.globalPath)
+    }
+
+    let skills: string[]
+
+    if (args.skill) {
+      skills = [args.skill as string]
+    } else {
+      // Interactive mode
+      const managedSkills = Object.keys(registry.skills)
+
+      if (managedSkills.length === 0) {
+        console.log("No skills managed.")
+        return
+      }
+
+      const result = await p.multiselect({
+        message: "Select skills to uninstall",
+        options: managedSkills.map((s) => ({ value: s, label: s })),
+        required: true,
+      })
+
+      if (p.isCancel(result)) process.exit(0)
+      skills = result as string[]
+    }
+
+    // Confirm
+    const confirm = await p.confirm({
+      message: `Uninstall ${skills.length} skill(s)? This will remove them from all agents.`,
+      initialValue: false,
+    })
+
+    if (p.isCancel(confirm) || !confirm) {
+      console.log("Cancelled.")
+      return
+    }
+
+    // Ask about deleting files
+    const deleteFiles = await p.confirm({
+      message: "Also delete skill files from Simba's store?",
+      initialValue: true,
+    })
+
+    if (p.isCancel(deleteFiles)) {
+      console.log("Cancelled.")
+      return
+    }
+
+    await runUninstall({
+      skills,
+      skillsDir: getSkillsDir(),
+      registryPath: getRegistryPath(),
+      agentPaths,
+      deleteFiles: deleteFiles as boolean,
+    })
+  },
+})