@skillsgate/tui 0.1.1

package/src/db/skills.ts

@@ -0,0 +1,138 @@
+import type { Database } from "bun:sqlite"
+import crypto from "node:crypto"
+
+export interface RemoteSkill {
+  id: string
+  serverId: string
+  name: string
+  description: string | null
+  remotePath: string
+  content: string | null
+  contentHash: string | null
+  syncedAt: string
+}
+
+export interface RemoteSkillWithServer extends RemoteSkill {
+  serverLabel: string
+}
+
+interface SkillRow {
+  id: string
+  server_id: string
+  name: string
+  description: string | null
+  remote_path: string
+  content: string | null
+  content_hash: string | null
+  synced_at: string
+}
+
+interface SkillRowWithServer extends SkillRow {
+  server_label: string
+}
+
+function rowToSkill(row: SkillRow): RemoteSkill {
+  return {
+    id: row.id,
+    serverId: row.server_id,
+    name: row.name,
+    description: row.description,
+    remotePath: row.remote_path,
+    content: row.content,
+    contentHash: row.content_hash,
+    syncedAt: row.synced_at,
+  }
+}
+
+export class RemoteSkillStore {
+  private db: Database
+
+  constructor(db: Database) {
+    this.db = db
+  }
+
+  listByServer(serverId: string): RemoteSkill[] {
+    const rows = this.db
+      .query("SELECT * FROM remote_skills WHERE server_id = ? ORDER BY name ASC")
+      .all(serverId) as SkillRow[]
+    return rows.map(rowToSkill)
+  }
+
+  listAll(): RemoteSkillWithServer[] {
+    const rows = this.db
+      .query(
+        `SELECT rs.*, s.label as server_label
+         FROM remote_skills rs
+         JOIN remote_servers s ON s.id = rs.server_id
+         ORDER BY rs.name ASC`
+      )
+      .all() as SkillRowWithServer[]
+    return rows.map((row) => ({
+      ...rowToSkill(row),
+      serverLabel: row.server_label,
+    }))
+  }
+
+  upsert(skill: {
+    serverId: string
+    name: string
+    description: string | null
+    remotePath: string
+    content: string | null
+    contentHash: string | null
+  }): void {
+    const id = crypto.randomUUID()
+    this.db
+      .query(
+        `INSERT INTO remote_skills (id, server_id, name, description, remote_path, content, content_hash, synced_at)
+         VALUES (?, ?, ?, ?, ?, ?, ?, datetime('now'))
+         ON CONFLICT(server_id, remote_path)
+         DO UPDATE SET
+           name = excluded.name,
+           description = excluded.description,
+           content = excluded.content,
+           content_hash = excluded.content_hash,
+           synced_at = excluded.synced_at`
+      )
+      .run(
+        id,
+        skill.serverId,
+        skill.name,
+        skill.description,
+        skill.remotePath,
+        skill.content,
+        skill.contentHash,
+      )
+  }
+
+  /**
+   * Remove remote skills that no longer exist on the remote server.
+   * Returns the number of removed rows.
+   */
+  removeStale(serverId: string, currentPaths: string[]): number {
+    if (currentPaths.length === 0) {
+      // All skills were removed from remote; delete everything for this server
+      const info = this.db
+        .query("DELETE FROM remote_skills WHERE server_id = ?")
+        .run(serverId)
+      return info.changes
+    }
+
+    // Build a parameterized IN clause
+    const placeholders = currentPaths.map(() => "?").join(", ")
+    const info = this.db
+      .query(
+        `DELETE FROM remote_skills
+         WHERE server_id = ? AND remote_path NOT IN (${placeholders})`
+      )
+      .run(serverId, ...currentPaths)
+    return info.changes
+  }
+
+  getContent(id: string): string | null {
+    const row = this.db
+      .query("SELECT content FROM remote_skills WHERE id = ?")
+      .get(id) as { content: string | null } | null
+    return row?.content ?? null
+  }
+}

package/src/db/ssh.ts

@@ -0,0 +1,319 @@
+import { spawn } from "node:child_process"
+import os from "node:os"
+import path from "node:path"
+import fs from "node:fs"
+import crypto from "node:crypto"
+import type { RemoteServer } from "./servers.js"
+import type { RemoteServerStore } from "./servers.js"
+import type { RemoteSkillStore } from "./skills.js"
+
+// ---------- SSH Execution ----------
+
+export interface SshResult {
+  stdout: string
+  stderr: string
+  exitCode: number
+}
+
+export function buildSshArgs(server: RemoteServer): string[] {
+  const home = os.homedir()
+  const args = [
+    "-p",
+    String(server.port),
+    "-o",
+    "ConnectTimeout=10",
+    "-o",
+    "BatchMode=yes",
+    "-o",
+    "StrictHostKeyChecking=accept-new",
+  ]
+
+  if (server.sshKeyPath) {
+    const resolved = server.sshKeyPath.startsWith("~/")
+      ? path.join(home, server.sshKeyPath.slice(2))
+      : server.sshKeyPath
+    args.push("-i", resolved)
+  } else {
+    // Auto-discover first existing default key
+    for (const name of ["id_ed25519", "id_rsa", "id_ecdsa"]) {
+      const keyPath = path.join(home, ".ssh", name)
+      if (fs.existsSync(keyPath)) {
+        args.push("-i", keyPath)
+        break
+      }
+    }
+  }
+
+  args.push(`${server.username}@${server.host}`)
+  return args
+}
+
+export function sshExec(server: RemoteServer, command: string): Promise<SshResult> {
+  return new Promise((resolve, reject) => {
+    const args = [...buildSshArgs(server), command]
+    const proc = spawn("ssh", args, {
+      stdio: ["ignore", "pipe", "pipe"],
+    })
+
+    let stdout = ""
+    let stderr = ""
+
+    proc.stdout.on("data", (data: Buffer) => {
+      stdout += data.toString()
+    })
+
+    proc.stderr.on("data", (data: Buffer) => {
+      stderr += data.toString()
+    })
+
+    proc.on("error", (err) => {
+      reject(new Error(`Failed to spawn ssh: ${err.message}`))
+    })
+
+    proc.on("close", (exitCode) => {
+      resolve({
+        stdout,
+        stderr,
+        exitCode: exitCode ?? 1,
+      })
+    })
+  })
+}
+
+export async function testConnection(
+  server: RemoteServer
+): Promise<{ ok: boolean; error?: string }> {
+  try {
+    const result = await sshExec(server, "echo ok")
+    if (result.exitCode === 0 && result.stdout.trim() === "ok") {
+      return { ok: true }
+    }
+    return { ok: false, error: result.stderr.trim() || `Exit code ${result.exitCode}` }
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err)
+    return { ok: false, error: msg }
+  }
+}
+
+// ---------- Remote Skill Scanner ----------
+
+function shellQuotePath(remotePath: string): string {
+  let expanded = remotePath
+  if (expanded.startsWith("~/")) {
+    expanded = "$HOME/" + expanded.slice(2)
+  } else if (expanded === "~") {
+    expanded = "$HOME"
+  }
+  return `"${expanded.replace(/"/g, '\\"')}"`
+}
+
+const DELIMITER_PREFIX = "---SKILLSGATE_DELIM:"
+const DELIMITER_SUFFIX = "---"
+
+interface ScannedRemoteSkill {
+  name: string
+  description: string | null
+  remotePath: string
+  content: string
+  contentHash: string
+}
+
+/**
+ * Parse simple frontmatter from SKILL.md content to extract name and description.
+ */
+function parseFrontmatter(content: string): { name: string; description: string | null } {
+  const lines = content.split("\n")
+  if (lines[0]?.trim() !== "---") {
+    // No frontmatter; derive name from first heading
+    for (const line of lines) {
+      if (line.startsWith("# ")) {
+        return { name: line.slice(2).trim(), description: null }
+      }
+    }
+    return { name: "unknown", description: null }
+  }
+
+  let name = "unknown"
+  let description: string | null = null
+
+  for (let i = 1; i < lines.length; i++) {
+    if (lines[i].trim() === "---") break
+    const match = lines[i].match(/^(\w+):\s*(.+)/)
+    if (match) {
+      const key = match[1].toLowerCase()
+      const value = match[2].trim().replace(/^["']|["']$/g, "")
+      if (key === "name") name = value
+      if (key === "description") description = value
+    }
+  }
+
+  return { name, description }
+}
+
+function sha256(content: string): string {
+  return crypto.createHash("sha256").update(content).digest("hex")
+}
+
+export async function scanRemoteSkills(
+  server: RemoteServer
+): Promise<ScannedRemoteSkill[]> {
+  const basePath = shellQuotePath(server.skillsBasePath)
+
+  // Round trip 1: Find all SKILL.md files
+  const findResult = await sshExec(
+    server,
+    `find ${basePath} -name 'SKILL.md' -type f 2>/dev/null`
+  )
+  if (findResult.exitCode !== 0 && findResult.stdout.trim() === "") {
+    throw new Error(`Find failed: ${findResult.stderr.trim()}`)
+  }
+
+  const paths = findResult.stdout.trim().split("\n").filter(Boolean)
+  if (paths.length === 0) return []
+
+  // Round trip 2: Batch read all files in a single SSH call
+  const catCommands = paths
+    .map((p) => {
+      const escaped = `'${p.replace(/'/g, "'\\''")}'`
+      return `echo '${DELIMITER_PREFIX}${p}${DELIMITER_SUFFIX}' && cat ${escaped}`
+    })
+    .join(" && ")
+
+  const catResult = await sshExec(server, catCommands)
+  if (catResult.exitCode !== 0) {
+    throw new Error(`Batch read failed: ${catResult.stderr.trim()}`)
+  }
+
+  return parseDelimitedOutput(catResult.stdout)
+}
+
+function parseDelimitedOutput(output: string): ScannedRemoteSkill[] {
+  const skills: ScannedRemoteSkill[] = []
+  let currentPath: string | null = null
+  let currentLines: string[] = []
+
+  for (const line of output.split("\n")) {
+    if (line.startsWith(DELIMITER_PREFIX) && line.endsWith(DELIMITER_SUFFIX)) {
+      // Flush previous skill
+      if (currentPath) {
+        const content = currentLines.join("\n").trim()
+        const { name, description } = parseFrontmatter(content)
+        skills.push({
+          name,
+          description,
+          remotePath: currentPath,
+          content,
+          contentHash: sha256(content),
+        })
+      }
+      // Start next skill
+      currentPath = line.slice(DELIMITER_PREFIX.length, -DELIMITER_SUFFIX.length)
+      currentLines = []
+    } else {
+      currentLines.push(line)
+    }
+  }
+
+  // Flush last skill
+  if (currentPath) {
+    const content = currentLines.join("\n").trim()
+    const { name, description } = parseFrontmatter(content)
+    skills.push({
+      name,
+      description,
+      remotePath: currentPath,
+      content,
+      contentHash: sha256(content),
+    })
+  }
+
+  return skills
+}
+
+// ---------- Sync Orchestrator ----------
+
+export interface SyncResult {
+  added: number
+  updated: number
+  removed: number
+  unchanged: number
+  total: number
+  log: string[]
+}
+
+export async function syncRemoteServer(
+  server: RemoteServer,
+  serverStore: RemoteServerStore,
+  skillStore: RemoteSkillStore
+): Promise<SyncResult> {
+  const log: string[] = []
+  log.push(`Connecting to ${server.username}@${server.host}...`)
+
+  try {
+    const scanned = await scanRemoteSkills(server)
+
+    log.push(`Found ${scanned.length} skill(s):`)
+    for (const s of scanned) {
+      log.push(`  ${s.remotePath}`)
+    }
+
+    // Get existing skills for comparison
+    const existing = skillStore.listByServer(server.id)
+    const existingByPath = new Map(existing.map((s) => [s.remotePath, s]))
+
+    let added = 0
+    let updated = 0
+    let unchanged = 0
+
+    for (const scannedSkill of scanned) {
+      const prev = existingByPath.get(scannedSkill.remotePath)
+      if (!prev) {
+        added++
+      } else if (prev.contentHash !== scannedSkill.contentHash) {
+        updated++
+      } else {
+        unchanged++
+      }
+
+      skillStore.upsert({
+        serverId: server.id,
+        name: scannedSkill.name,
+        description: scannedSkill.description,
+        remotePath: scannedSkill.remotePath,
+        content: scannedSkill.content,
+        contentHash: scannedSkill.contentHash,
+      })
+    }
+
+    // Remove stale skills
+    const currentPaths = scanned.map((s) => s.remotePath)
+    const removed = skillStore.removeStale(server.id, currentPaths)
+
+    // Update sync status on success
+    serverStore.updateSyncStatus(server.id, null)
+
+    const summary = `Synced: ${added} new, ${updated} updated, ${removed} removed, ${unchanged} unchanged`
+    log.push(summary)
+
+    return {
+      added,
+      updated,
+      removed,
+      unchanged,
+      total: scanned.length,
+      log,
+    }
+  } catch (err) {
+    const errorMsg = err instanceof Error ? err.message : String(err)
+    log.push(`SSH connection failed: ${errorMsg}`)
+    serverStore.updateSyncStatus(server.id, errorMsg)
+    return {
+      added: 0,
+      updated: 0,
+      removed: 0,
+      unchanged: 0,
+      total: 0,
+      log,
+    }
+  }
+}

package/src/index.tsx

@@ -0,0 +1,37 @@
+import { createCliRenderer } from "@opentui/core"
+import { createRoot } from "@opentui/react"
+import { openDb } from "./db/index.js"
+import { App } from "./app.js"
+
+// Open the local SQLite database at ~/.skillsgate/skillsgate.db
+const db = openDb()
+
+const renderer = await createCliRenderer({
+  exitOnCtrlC: false,
+  useAlternateScreen: true,
+})
+
+const root = createRoot(renderer)
+root.render(<App db={db} />)
+
+// Make cleanExit available globally so layout.tsx can call it
+;(globalThis as any).__skillsgateTuiCleanExit = function cleanExit() {
+  try {
+    db.close()
+  } catch {
+    // ignore close errors
+  }
+  try {
+    renderer.destroy()
+  } catch {
+    // ignore destroy errors
+  }
+  // Ensure terminal is fully restored
+  process.stdout.write("\x1B[?1049l") // switch to main screen
+  process.stdout.write("\x1B[?25h")   // show cursor
+  process.stdout.write("\x1Bc")       // full reset (RIS)
+  process.exit(0)
+}
+
+process.on("SIGINT", (globalThis as any).__skillsgateTuiCleanExit)
+process.on("SIGTERM", (globalThis as any).__skillsgateTuiCleanExit)

package/src/store/context.tsx

@@ -0,0 +1,26 @@
+import { createContext, useContext, useReducer, type Dispatch, type ReactNode } from "react"
+import type { AppState, Action } from "./types.js"
+import { appReducer, initialState } from "./reducers.js"
+
+const StoreContext = createContext<AppState>(initialState)
+const DispatchContext = createContext<Dispatch<Action>>(() => {})
+
+export function StoreProvider({ children }: { children: ReactNode }) {
+  const [state, dispatch] = useReducer(appReducer, initialState)
+
+  return (
+    <StoreContext.Provider value={state}>
+      <DispatchContext.Provider value={dispatch}>
+        {children}
+      </DispatchContext.Provider>
+    </StoreContext.Provider>
+  )
+}
+
+export function useStore(): AppState {
+  return useContext(StoreContext)
+}
+
+export function useDispatch(): Dispatch<Action> {
+  return useContext(DispatchContext)
+}

package/src/store/reducers.ts

@@ -0,0 +1,126 @@
+import type { AppState, Action, FocusedPane } from "./types.js"
+
+const FOCUS_ORDER: FocusedPane[] = ["agents", "search", "list"]
+
+export const initialState: AppState = {
+  activeView: "home",
+  previousView: null,
+  auth: null,
+  detectedAgents: [],
+  selectedAgentFilter: "all",
+  installedSkills: [],
+  installedLoading: true,
+  installedFilter: "",
+  searchQuery: "",
+  searchResults: [],
+  searchLoading: false,
+  favorites: [],
+  favoritesLoading: false,
+  selectedSkill: null,
+  selectedServerId: null,
+  showHelp: false,
+  focusedPane: "list",
+  notification: null,
+}
+
+export function appReducer(state: AppState, action: Action): AppState {
+  switch (action.type) {
+    case "NAVIGATE":
+      return {
+        ...state,
+        previousView: state.activeView,
+        activeView: action.view,
+      }
+
+    case "GO_BACK":
+      if (!state.previousView) return state
+      return {
+        ...state,
+        activeView: state.previousView,
+        previousView: null,
+      }
+
+    case "SET_AUTH":
+      return { ...state, auth: action.auth }
+
+    case "SET_DETECTED_AGENTS":
+      return { ...state, detectedAgents: action.agents }
+
+    case "UPDATE_AGENT_COUNTS":
+      return {
+        ...state,
+        detectedAgents: state.detectedAgents.map(a => ({
+          ...a,
+          skillCount: action.counts[a.name] ?? 0,
+        })),
+      }
+
+    case "SET_AGENT_FILTER":
+      return { ...state, selectedAgentFilter: action.filter }
+
+    case "SET_INSTALLED_SKILLS":
+      return { ...state, installedSkills: action.skills, installedLoading: false }
+
+    case "SET_INSTALLED_LOADING":
+      return { ...state, installedLoading: action.loading }
+
+    case "SET_INSTALLED_FILTER":
+      return { ...state, installedFilter: action.filter }
+
+    case "SET_SEARCH_QUERY":
+      return { ...state, searchQuery: action.query }
+
+    case "SET_SEARCH_RESULTS":
+      return { ...state, searchResults: action.results, searchLoading: false }
+
+    case "SET_SEARCH_LOADING":
+      return { ...state, searchLoading: action.loading }
+
+    case "SET_FAVORITES":
+      return { ...state, favorites: action.favorites, favoritesLoading: false }
+
+    case "SET_FAVORITES_LOADING":
+      return { ...state, favoritesLoading: action.loading }
+
+    case "SELECT_SKILL":
+      return {
+        ...state,
+        selectedSkill: action.skill,
+        previousView: state.activeView,
+        activeView: "detail",
+      }
+
+    case "PREVIEW_SKILL":
+      return { ...state, selectedSkill: action.skill }
+
+    case "CLEAR_SKILL":
+      return { ...state, selectedSkill: null }
+
+    case "SHOW_NOTIFICATION":
+      return { ...state, notification: action.notification }
+
+    case "CLEAR_NOTIFICATION":
+      return { ...state, notification: null }
+
+    case "TOGGLE_HELP":
+      return { ...state, showHelp: !state.showHelp }
+
+    case "SET_FOCUSED_PANE":
+      return { ...state, focusedPane: action.pane }
+
+    case "CYCLE_FOCUS": {
+      const currentIdx = FOCUS_ORDER.indexOf(state.focusedPane)
+      const nextIdx = (currentIdx + 1) % FOCUS_ORDER.length
+      return { ...state, focusedPane: FOCUS_ORDER[nextIdx] }
+    }
+
+    case "REFRESH_SKILLS":
+      return { ...state, installedLoading: true }
+
+    case "SET_SELECTED_SERVER":
+      return { ...state, selectedServerId: action.serverId }
+
+    default:
+      return state
+  }
+}