simba-skills 0.1.2

package/src/commands/detect.ts

@@ -0,0 +1,63 @@
+import { defineCommand } from "citty"
+import { ConfigStore } from "../core/config-store"
+import { AgentRegistry } from "../core/agent-registry"
+import { getConfigPath } from "../utils/paths"
+
+export default defineCommand({
+  meta: {
+    name: "detect",
+    description: "Scan for installed agents and skills",
+  },
+  args: {
+    refresh: {
+      type: "boolean",
+      description: "Force rescan even if already detected",
+      default: false,
+    },
+  },
+  async run({ args }) {
+    const configStore = new ConfigStore(getConfigPath())
+    const config = await configStore.load()
+
+    const registry = new AgentRegistry(config.agents)
+    const detected = await registry.detectAgents()
+
+    // Update config with detection results
+    for (const [id, agent] of Object.entries(detected)) {
+      config.agents[id] = agent
+    }
+
+    // Scan skills from detected agents
+    let totalSkills = 0
+    for (const [id, agent] of Object.entries(detected)) {
+      if (!agent.detected) continue
+
+      const skills = await registry.listSkills(id)
+      totalSkills += skills.length
+
+      for (const skill of skills) {
+        config.skills[skill.name] = {
+          ...config.skills[skill.name],
+          ...skill,
+          agents: [
+            ...new Set([
+              ...(config.skills[skill.name]?.agents ?? []),
+              id,
+            ]),
+          ],
+        }
+      }
+    }
+
+    await configStore.save(config)
+
+    // Output results
+    console.log("\nDetected agents:")
+    for (const [id, agent] of Object.entries(detected)) {
+      const status = agent.detected ? "✓" : "─"
+      console.log(`  ${status} ${agent.name}`)
+    }
+
+    console.log(`\nTotal skills found: ${totalSkills}`)
+  },
+})

package/src/commands/doctor.ts

@@ -0,0 +1,169 @@
+import { defineCommand } from "citty"
+import { access } from "node:fs/promises"
+import { join } from "node:path"
+import * as p from "@clack/prompts"
+import { ConfigStore } from "../core/config-store"
+import { RegistryStore } from "../core/registry-store"
+import { AgentRegistry } from "../core/agent-registry"
+import { getConfigPath, getSkillsDir, getRegistryPath, expandPath } from "../utils/paths"
+import { isSymlink, getSymlinkTarget, createSymlink, removeSymlink } from "../utils/symlinks"
+import type { Agent } from "../core/types"
+
+interface BrokenLink {
+  skill: string
+  agent: string
+  path: string
+  reason: string
+}
+
+interface RogueFile {
+  skill: string
+  agent: string
+  path: string
+}
+
+export interface DoctorResults {
+  healthy: string[]
+  broken: BrokenLink[]
+  rogue: RogueFile[]
+}
+
+export interface DoctorOptions {
+  skillsDir: string
+  registryPath: string
+  agents: Record<string, Agent>
+}
+
+export async function runDoctor(options: DoctorOptions): Promise<DoctorResults> {
+  const registryStore = new RegistryStore(options.registryPath)
+  const registry = await registryStore.load()
+
+  const results: DoctorResults = {
+    healthy: [],
+    broken: [],
+    rogue: [],
+  }
+
+  for (const [skillName, skill] of Object.entries(registry.skills)) {
+    let skillHealthy = true
+
+    for (const [agentId, assignment] of Object.entries(skill.assignments)) {
+      const agent = options.agents[agentId]
+      if (!agent || !agent.detected) continue
+
+      const agentSkillsDir = expandPath(agent.globalPath)
+      const expectedPath = join(agentSkillsDir, skillName)
+      const expectedTarget = join(options.skillsDir, skillName)
+
+      const pathIsSymlink = await isSymlink(expectedPath)
+
+      if (!pathIsSymlink) {
+        try {
+          await access(expectedPath)
+          results.rogue.push({ skill: skillName, agent: agentId, path: expectedPath })
+          skillHealthy = false
+        } catch {
+          results.broken.push({
+            skill: skillName,
+            agent: agentId,
+            path: expectedPath,
+            reason: "symlink missing",
+          })
+          skillHealthy = false
+        }
+        continue
+      }
+
+      const target = await getSymlinkTarget(expectedPath)
+
+      try {
+        await access(target!)
+      } catch {
+        results.broken.push({
+          skill: skillName,
+          agent: agentId,
+          path: expectedPath,
+          reason: "target missing",
+        })
+        skillHealthy = false
+        continue
+      }
+
+      if (target !== expectedTarget) {
+        results.broken.push({
+          skill: skillName,
+          agent: agentId,
+          path: expectedPath,
+          reason: `wrong target: ${target}`,
+        })
+        skillHealthy = false
+      }
+    }
+
+    if (skillHealthy) {
+      results.healthy.push(skillName)
+    }
+  }
+
+  return results
+}
+
+export default defineCommand({
+  meta: { name: "doctor", description: "Verify symlink integrity" },
+  args: {
+    fix: { type: "boolean", description: "Automatically fix issues", default: false },
+  },
+  async run({ args }) {
+    const configStore = new ConfigStore(getConfigPath())
+    const config = await configStore.load()
+
+    const agentRegistry = new AgentRegistry(config.agents)
+    const detected = await agentRegistry.detectAgents()
+
+    console.log("\nChecking symlink integrity...\n")
+
+    const results = await runDoctor({
+      skillsDir: getSkillsDir(),
+      registryPath: getRegistryPath(),
+      agents: detected,
+    })
+
+    for (const skill of results.healthy) {
+      console.log(`✓ ${skill}`)
+    }
+
+    for (const broken of results.broken) {
+      console.log(`✗ ${broken.skill}`)
+      console.log(`  └─ ${broken.agent}: BROKEN (${broken.reason})`)
+    }
+
+    for (const rogue of results.rogue) {
+      console.log(`⚠ ${rogue.skill}`)
+      console.log(`  └─ ${rogue.agent}: ROGUE (real file, not symlink)`)
+    }
+
+    console.log(`\nSummary: ${results.broken.length} broken, ${results.rogue.length} rogue, ${results.healthy.length} healthy`)
+
+    if (results.broken.length === 0 && results.rogue.length === 0) {
+      console.log("\nAll symlinks healthy!")
+      return
+    }
+
+    if (!args.fix) {
+      const shouldFix = await p.confirm({ message: "Fix issues?" })
+      if (p.isCancel(shouldFix) || !shouldFix) return
+    }
+
+    for (const broken of results.broken) {
+      const agent = detected[broken.agent]
+      if (!agent) continue
+
+      const expectedTarget = join(getSkillsDir(), broken.skill)
+      await removeSymlink(broken.path)
+      await createSymlink(expectedTarget, broken.path)
+      console.log(`Fixed: ${broken.skill} (${broken.agent})`)
+    }
+
+    console.log("\nRepairs complete!")
+  },
+})

package/src/commands/import.ts

@@ -0,0 +1,99 @@
+import { defineCommand } from "citty"
+import { ConfigStore } from "../core/config-store"
+import { AgentRegistry } from "../core/agent-registry"
+import { getConfigPath } from "../utils/paths"
+import { selectFromList, selectAgent } from "../utils/prompts"
+import { mkdir, access } from "node:fs/promises"
+import { join } from "node:path"
+
+export default defineCommand({
+  meta: {
+    name: "import",
+    description: "Copy a global skill into current project",
+  },
+  args: {
+    skill: {
+      type: "positional",
+      description: "Skill name to import",
+    },
+    to: {
+      type: "string",
+      description: "Target directory (defaults to detected agent's project path)",
+    },
+    agent: {
+      type: "string",
+      description: "Source agent (defaults to first detected with skill)",
+    },
+  },
+  async run({ args }) {
+    const configStore = new ConfigStore(getConfigPath())
+    const config = await configStore.load()
+    const registry = new AgentRegistry(config.agents)
+
+    let skillName = args.skill
+    let agentId = args.agent
+
+    // Interactive agent selection if not provided
+    if (!agentId) {
+      agentId = await selectAgent(config.agents, "Select source agent")
+    }
+
+    const agent = config.agents[agentId]
+    if (!agent || !agent.detected) {
+      console.error(`Agent not found or not detected: ${agentId}`)
+      process.exit(1)
+    }
+
+    // Get available skills from selected agent
+    const availableSkills = await registry.listSkills(agentId)
+
+    if (availableSkills.length === 0) {
+      console.log(`No skills found in ${agent.name}.`)
+      return
+    }
+
+    // Interactive skill selection if not provided
+    if (!skillName) {
+      skillName = await selectFromList(
+        "Select skill to import:",
+        availableSkills.map((s) => ({ value: s.name, label: s.name }))
+      )
+    }
+
+    // Find skill source
+    const sourcePath = registry.getSkillPath(skillName, agentId)
+    try {
+      await access(join(sourcePath, "SKILL.md"))
+    } catch {
+      console.error(`Skill not found in ${agentId}: ${skillName}`)
+      process.exit(1)
+    }
+
+    // Determine target path
+    let targetPath: string
+
+    if (args.to) {
+      targetPath = join(args.to, skillName)
+    } else {
+      // Use project path of source agent
+      targetPath = join(process.cwd(), agent.projectPath, skillName)
+    }
+
+    // Check if target exists
+    try {
+      await access(targetPath)
+      console.error(`Skill already exists at: ${targetPath}`)
+      process.exit(1)
+    } catch {
+      // Good, doesn't exist
+    }
+
+    // Copy skill
+    await mkdir(join(targetPath, ".."), { recursive: true })
+    await Bun.$`cp -r ${sourcePath} ${targetPath}`
+
+    console.log(`\nImported: ${skillName}`)
+    console.log(`From: ${agent.name}`)
+    console.log(`To: ${targetPath}`)
+  },
+})