@skillsgate/tui 0.1.1

package/src/data/use-skill-actions.ts

@@ -0,0 +1,333 @@
+import { useCallback } from "react"
+import { useStore, useDispatch } from "../store/context.js"
+import type { EnrichedSkill } from "../store/types.js"
+
+// CLI core imports -- these share the same Bun runtime
+import { parseSource } from "../../../cli/src/core/source-parser.js"
+import { cloneRepo, cleanupTempDir, fetchTreeSha } from "../../../cli/src/core/git.js"
+import { discoverSkills } from "../../../cli/src/core/skill-discovery.js"
+import {
+  installSkillForAgent,
+  removeSkillFromAgent,
+  removeCanonicalSkill,
+  sanitizeName,
+} from "../../../cli/src/core/installer.js"
+import {
+  addSkillToLock,
+  removeSkillFromLock,
+  readSkillLock,
+} from "../../../cli/src/core/skill-lock.js"
+import { agents, detectInstalledAgents } from "../../../cli/src/core/agents.js"
+import { downloadSkill } from "../../../cli/src/core/skillsgate-client.js"
+import { getToken } from "../../../cli/src/utils/auth-store.js"
+import type { Skill, AgentConfig, ParsedSource } from "../../../cli/src/types.js"
+
+interface UseSkillActionsResult {
+  installSkill: (skill: EnrichedSkill) => Promise<void>
+  removeSkill: (skill: EnrichedSkill) => Promise<void>
+  removeSkillFromOneAgent: (skill: EnrichedSkill, agentName: string) => Promise<void>
+  updateSkill: (skill: EnrichedSkill) => Promise<void>
+}
+
+/**
+ * Provides install, remove, and update actions for skills.
+ * Uses CLI core modules directly since they share the same Bun runtime.
+ */
+export function useSkillActions(): UseSkillActionsResult {
+  const state = useStore()
+  const dispatch = useDispatch()
+
+  /**
+   * Install a skill from its source (GitHub URL, SkillsGate slug, or install command).
+   */
+  const installSkill = useCallback(async (skill: EnrichedSkill) => {
+    dispatch({
+      type: "SHOW_NOTIFICATION",
+      notification: { type: "info", message: `Installing "${skill.name}"...` },
+    })
+
+    try {
+      // Determine the source from metadata or lock entry
+      const sourceStr = resolveSource(skill)
+      if (!sourceStr) {
+        dispatch({
+          type: "SHOW_NOTIFICATION",
+          notification: { type: "error", message: `Cannot determine source for "${skill.name}"` },
+        })
+        return
+      }
+
+      const source = parseSource(sourceStr)
+
+      // Detect installed agents to install to
+      const installedAgents = await detectInstalledAgents()
+      if (installedAgents.length === 0) {
+        dispatch({
+          type: "SHOW_NOTIFICATION",
+          notification: { type: "error", message: "No AI agents detected on this system" },
+        })
+        return
+      }
+
+      let tmpDir: string
+      if (source.type === "skillsgate") {
+        // Download from SkillsGate API
+        const token = await getToken()
+        tmpDir = await downloadSkill(source.username!, source.slug!, token)
+      } else if (source.type === "github") {
+        // Clone from GitHub
+        tmpDir = await cloneRepo(source)
+      } else {
+        // Local path -- use directly
+        tmpDir = source.localPath!
+      }
+
+      try {
+        // Discover skills in the cloned/downloaded directory
+        const skills = await discoverSkills(tmpDir, source.subpath)
+
+        if (skills.length === 0) {
+          dispatch({
+            type: "SHOW_NOTIFICATION",
+            notification: { type: "error", message: `No skills found in "${sourceStr}"` },
+          })
+          return
+        }
+
+        // Filter if a specific skill was requested
+        let targetSkills = skills
+        if (source.skillFilter) {
+          const filter = source.skillFilter.toLowerCase()
+          targetSkills = skills.filter((s) => s.name.toLowerCase() === filter)
+          if (targetSkills.length === 0) {
+            dispatch({
+              type: "SHOW_NOTIFICATION",
+              notification: { type: "error", message: `Skill "${source.skillFilter}" not found in "${sourceStr}"` },
+            })
+            return
+          }
+        }
+
+        let installedCount = 0
+
+        for (const skillToInstall of targetSkills) {
+          // Install to all detected agents
+          for (const agent of installedAgents) {
+            const result = await installSkillForAgent(
+              skillToInstall,
+              agent,
+              "global",
+              "symlink",
+            )
+            if (result.success) {
+              installedCount++
+            }
+          }
+
+          // Update lock file
+          await addSkillToLock(sanitizeName(skillToInstall.name), {
+            source: sourceStr,
+            sourceType: source.type,
+            originalUrl: source.url,
+            skillFolderHash: "",
+          })
+        }
+
+        // Trigger refresh
+        dispatch({ type: "REFRESH_SKILLS" })
+
+        const skillNames = targetSkills.map((s) => s.name).join(", ")
+        dispatch({
+          type: "SHOW_NOTIFICATION",
+          notification: {
+            type: "success",
+            message: `Installed ${targetSkills.length} skill(s): ${skillNames} to ${installedAgents.length} agent(s)`,
+          },
+        })
+      } finally {
+        // Clean up temp directory (only if it was a temp clone/download)
+        if (source.type !== "local") {
+          await cleanupTempDir(tmpDir)
+        }
+      }
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err)
+      dispatch({
+        type: "SHOW_NOTIFICATION",
+        notification: { type: "error", message: `Install failed: ${msg}` },
+      })
+    }
+  }, [dispatch])
+
+  /**
+   * Remove a skill from all agents and the lock file.
+   */
+  const removeSkill = useCallback(async (skill: EnrichedSkill) => {
+    dispatch({
+      type: "SHOW_NOTIFICATION",
+      notification: { type: "info", message: `Removing "${skill.name}"...` },
+    })
+
+    try {
+      const safeName = sanitizeName(skill.name)
+
+      // Remove from all agent directories
+      const installedAgents = await detectInstalledAgents()
+      for (const agent of installedAgents) {
+        await removeSkillFromAgent(safeName, agent, "global")
+      }
+
+      // Remove canonical copy
+      await removeCanonicalSkill(skill.name)
+
+      // Remove from lock file
+      await removeSkillFromLock(safeName)
+
+      // Trigger refresh
+      dispatch({ type: "REFRESH_SKILLS" })
+
+      dispatch({
+        type: "SHOW_NOTIFICATION",
+        notification: { type: "success", message: `Removed "${skill.name}"` },
+      })
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err)
+      dispatch({
+        type: "SHOW_NOTIFICATION",
+        notification: { type: "error", message: `Remove failed: ${msg}` },
+      })
+    }
+  }, [dispatch])
+
+  /**
+   * Remove a skill from a single agent only (delete its symlink).
+   * If this was the last agent, also removes the canonical copy and lock entry.
+   */
+  const removeSkillFromOneAgent = useCallback(async (skill: EnrichedSkill, agentName: string) => {
+    const agent = agents[agentName]
+    if (!agent) {
+      dispatch({
+        type: "SHOW_NOTIFICATION",
+        notification: { type: "error", message: `Unknown agent: ${agentName}` },
+      })
+      return
+    }
+
+    dispatch({
+      type: "SHOW_NOTIFICATION",
+      notification: { type: "info", message: `Removing "${skill.name}" from ${agent.displayName}...` },
+    })
+
+    try {
+      const safeName = sanitizeName(skill.name)
+      await removeSkillFromAgent(safeName, agent, "global")
+
+      // If this was the last agent, also remove canonical + lock
+      const remainingAgents = skill.agents.filter(a => a !== agentName)
+      if (remainingAgents.length === 0) {
+        await removeCanonicalSkill(skill.name)
+        await removeSkillFromLock(safeName)
+      }
+
+      dispatch({ type: "REFRESH_SKILLS" })
+      dispatch({
+        type: "SHOW_NOTIFICATION",
+        notification: {
+          type: "success",
+          message: remainingAgents.length > 0
+            ? `Removed "${skill.name}" from ${agent.displayName}`
+            : `Removed "${skill.name}" completely`,
+        },
+      })
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err)
+      dispatch({
+        type: "SHOW_NOTIFICATION",
+        notification: { type: "error", message: `Remove failed: ${msg}` },
+      })
+    }
+  }, [dispatch])
+
+  /**
+   * Update a skill by re-fetching from its source.
+   * For GitHub skills: checks tree SHA for changes before re-installing.
+   * For SkillsGate skills: always re-downloads.
+   */
+  const updateSkill = useCallback(async (skill: EnrichedSkill) => {
+    if (!skill.lock) {
+      dispatch({
+        type: "SHOW_NOTIFICATION",
+        notification: { type: "error", message: `No source information for "${skill.name}"` },
+      })
+      return
+    }
+
+    dispatch({
+      type: "SHOW_NOTIFICATION",
+      notification: { type: "info", message: `Checking for updates to "${skill.name}"...` },
+    })
+
+    try {
+      const source = parseSource(skill.lock.source)
+
+      if (source.type === "github") {
+        // Check if the tree SHA has changed
+        const newSha = await fetchTreeSha(source.owner, source.repo, "")
+        if (newSha && newSha === skill.lock.skillFolderHash) {
+          dispatch({
+            type: "SHOW_NOTIFICATION",
+            notification: { type: "info", message: `"${skill.name}" is already up to date` },
+          })
+          return
+        }
+      }
+
+      // Re-install (reuses the install flow)
+      await installSkill(skill)
+
+      dispatch({
+        type: "SHOW_NOTIFICATION",
+        notification: { type: "success", message: `Updated "${skill.name}"` },
+      })
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err)
+      dispatch({
+        type: "SHOW_NOTIFICATION",
+        notification: { type: "error", message: `Update failed: ${msg}` },
+      })
+    }
+  }, [dispatch, installSkill])
+
+  return { installSkill, removeSkill, removeSkillFromOneAgent, updateSkill }
+}
+
+// ---------- Helpers ----------
+
+/**
+ * Resolves the source string for a skill from its metadata.
+ * Checks: lock.source, metadata.githubUrl, metadata.installCommand
+ */
+function resolveSource(skill: EnrichedSkill): string | null {
+  // From lock file entry
+  if (skill.lock?.source) {
+    return skill.lock.source
+  }
+
+  // From metadata (catalog skills)
+  const meta = skill.metadata
+  if (meta?.githubUrl && typeof meta.githubUrl === "string") {
+    return meta.githubUrl
+  }
+
+  // From install command (e.g. "skillsgate add @user/slug")
+  if (meta?.installCommand && typeof meta.installCommand === "string") {
+    const cmd = meta.installCommand as string
+    // Extract the source from "skillsgate add <source>" or "skillsgate install <source>"
+    const match = cmd.match(/skillsgate\s+(?:add|install)\s+(.+)/)
+    if (match) {
+      return match[1].trim()
+    }
+  }
+
+  return null
+}

package/src/db/context.tsx

@@ -0,0 +1,38 @@
+import { createContext, useContext, type ReactNode } from "react"
+import type { Database } from "bun:sqlite"
+import { SettingsStore } from "./settings.js"
+import { RemoteServerStore } from "./servers.js"
+import { RemoteSkillStore } from "./skills.js"
+
+export interface DbContext {
+  db: Database
+  settings: SettingsStore
+  servers: RemoteServerStore
+  skills: RemoteSkillStore
+}
+
+const DbCtx = createContext<DbContext | null>(null)
+
+interface DbProviderProps {
+  db: Database
+  children: ReactNode
+}
+
+export function DbProvider({ db, children }: DbProviderProps) {
+  const ctx: DbContext = {
+    db,
+    settings: new SettingsStore(db),
+    servers: new RemoteServerStore(db),
+    skills: new RemoteSkillStore(db),
+  }
+
+  return <DbCtx.Provider value={ctx}>{children}</DbCtx.Provider>
+}
+
+export function useDb(): DbContext {
+  const ctx = useContext(DbCtx)
+  if (!ctx) {
+    throw new Error("useDb must be used within a DbProvider")
+  }
+  return ctx
+}

package/src/db/index.ts

@@ -0,0 +1,19 @@
+import { Database } from "bun:sqlite"
+import os from "node:os"
+import path from "node:path"
+import fs from "node:fs"
+import { runMigrations } from "./migrations.js"
+
+const DB_DIR = path.join(os.homedir(), ".skillsgate")
+const DB_PATH = path.join(DB_DIR, "skillsgate.db")
+
+export function openDb(): Database {
+  fs.mkdirSync(DB_DIR, { recursive: true })
+  const db = new Database(DB_PATH)
+  db.exec("PRAGMA journal_mode=WAL")
+  db.exec("PRAGMA foreign_keys=ON")
+  runMigrations(db)
+  return db
+}
+
+export type { Database } from "bun:sqlite"

package/src/db/migrations.ts

@@ -0,0 +1,72 @@
+import type { Database } from "bun:sqlite"
+
+interface Migration {
+  version: number
+  up: string
+}
+
+const MIGRATIONS: Migration[] = [
+  {
+    version: 1,
+    up: `
+      CREATE TABLE IF NOT EXISTS schema_version (
+        version INTEGER PRIMARY KEY
+      );
+
+      CREATE TABLE IF NOT EXISTS settings (
+        key   TEXT PRIMARY KEY,
+        value TEXT NOT NULL,
+        updated_at TEXT NOT NULL DEFAULT (datetime('now'))
+      );
+
+      CREATE TABLE IF NOT EXISTS remote_servers (
+        id              TEXT PRIMARY KEY,
+        label           TEXT NOT NULL,
+        host            TEXT NOT NULL,
+        port            INTEGER NOT NULL DEFAULT 22,
+        username        TEXT NOT NULL,
+        skills_base_path TEXT NOT NULL DEFAULT '~/.agents/skills',
+        ssh_key_path    TEXT,
+        last_sync_at    TEXT,
+        last_sync_error TEXT,
+        created_at      TEXT NOT NULL DEFAULT (datetime('now')),
+        UNIQUE(host, port, username)
+      );
+
+      CREATE TABLE IF NOT EXISTS remote_skills (
+        id          TEXT PRIMARY KEY,
+        server_id   TEXT NOT NULL REFERENCES remote_servers(id) ON DELETE CASCADE,
+        name        TEXT NOT NULL,
+        description TEXT,
+        remote_path TEXT NOT NULL,
+        content     TEXT,
+        content_hash TEXT,
+        synced_at   TEXT NOT NULL DEFAULT (datetime('now')),
+        UNIQUE(server_id, remote_path)
+      );
+
+      CREATE INDEX IF NOT EXISTS idx_remote_skills_server ON remote_skills(server_id);
+
+      INSERT OR IGNORE INTO schema_version VALUES (1);
+    `,
+  },
+]
+
+function getCurrentVersion(db: Database): number {
+  try {
+    const row = db.query("SELECT MAX(version) as v FROM schema_version").get() as { v: number | null } | null
+    return row?.v ?? 0
+  } catch {
+    // Table doesn't exist yet
+    return 0
+  }
+}
+
+export function runMigrations(db: Database): void {
+  const current = getCurrentVersion(db)
+  for (const migration of MIGRATIONS) {
+    if (migration.version > current) {
+      db.exec(migration.up)
+    }
+  }
+}

package/src/db/servers.ts

@@ -0,0 +1,154 @@
+import type { Database } from "bun:sqlite"
+import crypto from "node:crypto"
+
+export interface RemoteServer {
+  id: string
+  label: string
+  host: string
+  port: number
+  username: string
+  skillsBasePath: string
+  sshKeyPath: string | null
+  lastSyncAt: string | null
+  lastSyncError: string | null
+  createdAt: string
+}
+
+interface ServerRow {
+  id: string
+  label: string
+  host: string
+  port: number
+  username: string
+  skills_base_path: string
+  ssh_key_path: string | null
+  last_sync_at: string | null
+  last_sync_error: string | null
+  created_at: string
+}
+
+function rowToServer(row: ServerRow): RemoteServer {
+  return {
+    id: row.id,
+    label: row.label,
+    host: row.host,
+    port: row.port,
+    username: row.username,
+    skillsBasePath: row.skills_base_path,
+    sshKeyPath: row.ssh_key_path,
+    lastSyncAt: row.last_sync_at,
+    lastSyncError: row.last_sync_error,
+    createdAt: row.created_at,
+  }
+}
+
+export type CreateServerInput = {
+  label: string
+  host: string
+  port: number
+  username: string
+  skillsBasePath: string
+  sshKeyPath?: string | null
+}
+
+export class RemoteServerStore {
+  private db: Database
+
+  constructor(db: Database) {
+    this.db = db
+  }
+
+  list(): RemoteServer[] {
+    const rows = this.db
+      .query("SELECT * FROM remote_servers ORDER BY label ASC")
+      .all() as ServerRow[]
+    return rows.map(rowToServer)
+  }
+
+  get(id: string): RemoteServer | null {
+    const row = this.db
+      .query("SELECT * FROM remote_servers WHERE id = ?")
+      .get(id) as ServerRow | null
+    return row ? rowToServer(row) : null
+  }
+
+  create(input: CreateServerInput): RemoteServer {
+    const id = crypto.randomUUID()
+    this.db
+      .query(
+        `INSERT INTO remote_servers (id, label, host, port, username, skills_base_path, ssh_key_path)
+         VALUES (?, ?, ?, ?, ?, ?, ?)`
+      )
+      .run(
+        id,
+        input.label,
+        input.host,
+        input.port,
+        input.username,
+        input.skillsBasePath,
+        input.sshKeyPath ?? null,
+      )
+    return this.get(id)!
+  }
+
+  update(id: string, fields: Partial<CreateServerInput>): void {
+    const sets: string[] = []
+    const params: unknown[] = []
+
+    if (fields.label !== undefined) {
+      sets.push("label = ?")
+      params.push(fields.label)
+    }
+    if (fields.host !== undefined) {
+      sets.push("host = ?")
+      params.push(fields.host)
+    }
+    if (fields.port !== undefined) {
+      sets.push("port = ?")
+      params.push(fields.port)
+    }
+    if (fields.username !== undefined) {
+      sets.push("username = ?")
+      params.push(fields.username)
+    }
+    if (fields.skillsBasePath !== undefined) {
+      sets.push("skills_base_path = ?")
+      params.push(fields.skillsBasePath)
+    }
+    if (fields.sshKeyPath !== undefined) {
+      sets.push("ssh_key_path = ?")
+      params.push(fields.sshKeyPath)
+    }
+
+    if (sets.length === 0) return
+
+    params.push(id)
+    this.db.query(`UPDATE remote_servers SET ${sets.join(", ")} WHERE id = ?`).run(...params)
+  }
+
+  delete(id: string): void {
+    this.db.query("DELETE FROM remote_servers WHERE id = ?").run(id)
+  }
+
+  updateSyncStatus(id: string, error: string | null): void {
+    if (error) {
+      this.db
+        .query("UPDATE remote_servers SET last_sync_error = ? WHERE id = ?")
+        .run(error, id)
+    } else {
+      this.db
+        .query(
+          "UPDATE remote_servers SET last_sync_at = datetime('now'), last_sync_error = NULL WHERE id = ?"
+        )
+        .run(id)
+    }
+  }
+
+  /** Returns the count of remote skills for a given server. */
+  skillCount(serverId: string): number {
+    const row = this.db
+      .query("SELECT COUNT(*) as cnt FROM remote_skills WHERE server_id = ?")
+      .get(serverId) as { cnt: number } | null
+    return row?.cnt ?? 0
+  }
+}

package/src/db/settings.ts

@@ -0,0 +1,43 @@
+import type { Database } from "bun:sqlite"
+
+export class SettingsStore {
+  private db: Database
+
+  constructor(db: Database) {
+    this.db = db
+  }
+
+  get<T>(key: string, defaultValue: T): T {
+    const row = this.db.query("SELECT value FROM settings WHERE key = ?").get(key) as { value: string } | null
+    if (!row) return defaultValue
+    try {
+      return JSON.parse(row.value) as T
+    } catch {
+      return defaultValue
+    }
+  }
+
+  set<T>(key: string, value: T): void {
+    this.db
+      .query(
+        `INSERT INTO settings (key, value, updated_at)
+         VALUES (?, ?, datetime('now'))
+         ON CONFLICT(key)
+         DO UPDATE SET value = excluded.value, updated_at = excluded.updated_at`
+      )
+      .run(key, JSON.stringify(value))
+  }
+
+  getAll(): Record<string, unknown> {
+    const rows = this.db.query("SELECT key, value FROM settings").all() as { key: string; value: string }[]
+    const result: Record<string, unknown> = {}
+    for (const row of rows) {
+      try {
+        result[row.key] = JSON.parse(row.value)
+      } catch {
+        result[row.key] = row.value
+      }
+    }
+    return result
+  }
+}