@skillsgate/tui 0.1.10 → 0.1.13

package/src/data/use-installed-skills.ts

@@ -1,14 +1,97 @@
 import { useEffect } from "react"
 import fs from "node:fs/promises"
 import path from "node:path"
+import os from "node:os"
 import matter from "gray-matter"
 import { useStore, useDispatch } from "../store/context.js"
+import { useDb } from "../db/context.js"
 import { agents } from "../../../cli/src/core/agents.js"
 import { readSkillLock } from "../../../cli/src/core/skill-lock.js"
 import { SKILL_MD } from "../../../cli/src/constants.js"
 import type { EnrichedSkill } from "../store/types.js"
 import type { AgentType, SkillLockFile } from "../../../cli/src/types.js"
 
+const home = os.homedir()
+const PROJECT_PROBES = [
+  ".claude/skills",
+  ".cursor/skills",
+  ".cursor/rules",
+  ".codex/skills",
+  ".github/skills",
+  ".windsurf/skills",
+  ".continue/skills",
+  ".cline/skills",
+  ".amp/skills",
+  ".opencode/skills",
+  ".goose/skills",
+  ".junie/skills",
+  ".kilo-code/skills",
+  ".pear-ai/skills",
+  ".roo-code/skills",
+  ".trae/skills",
+  ".zed/skills",
+  ".agents/skills",
+]
+
+function getScopeForPath(resolvedPath: string): "global" | "project" | "custom" {
+  const globalRoots = [
+    path.join(home, ".agents", "skills"),
+    ...Object.values(agents).map((agent) => agent.globalSkillsDir),
+  ].map((root) => path.resolve(root))
+
+  if (globalRoots.some((root) => resolvedPath.startsWith(root))) {
+    return "global"
+  }
+
+  if (resolvedPath.split(path.sep).some((segment) => segment.startsWith("."))) {
+    return "project"
+  }
+
+  return "custom"
+}
+
+function getProjectNameForPath(resolvedPath: string): string | null {
+  const parts = path.resolve(resolvedPath).split(path.sep).filter(Boolean)
+  for (let i = 1; i < parts.length; i++) {
+    if (parts[i].startsWith(".")) {
+      return parts[i - 1] || null
+    }
+  }
+  return null
+}
+
+async function listSupportingFiles(skillDir: string): Promise<Array<{ relativePath: string; size: number }>> {
+  const files: Array<{ relativePath: string; size: number }> = []
+
+  async function walk(currentDir: string, prefix = ""): Promise<void> {
+    const entries = await fs.readdir(currentDir, { withFileTypes: true })
+    for (const entry of entries) {
+      const absolutePath = path.join(currentDir, entry.name)
+      const relativePath = prefix ? path.join(prefix, entry.name) : entry.name
+
+      if (entry.isDirectory()) {
+        await walk(absolutePath, relativePath)
+        continue
+      }
+
+      if (!entry.isFile() || relativePath === SKILL_MD) continue
+      const stat = await fs.stat(absolutePath)
+      files.push({
+        relativePath: relativePath.split(path.sep).join("/"),
+        size: stat.size,
+      })
+    }
+  }
+
+  try {
+    await walk(skillDir)
+  } catch {
+    return []
+  }
+
+  return files.sort((a, b) => a.relativePath.localeCompare(b.relativePath))
+}
+
 /**
  * Scans all detected agent globalSkillsDir paths for SKILL.md files,
  * parses them with gray-matter, enriches with lock file data, and
@@ -17,6 +100,7 @@ import type { AgentType, SkillLockFile } from "../../../cli/src/types.js"
 export function useInstalledSkills() {
   const dispatch = useDispatch()
   const { installedLoading } = useStore()
+  const { settings } = useDb()
 
   useEffect(() => {
     // Only scan when installedLoading is true (initial mount or refresh triggered)
@@ -41,26 +125,37 @@ export function useInstalledSkills() {
               // Include both real directories and symlinks (skills are often symlinked)
               if (!entry.isDirectory() && !entry.isSymbolicLink()) continue
 
-              const skillMdPath = path.join(skillsDir, entry.name, SKILL_MD)
+              const skillDirPath = path.join(skillsDir, entry.name)
+              const canonicalPath = await fs.realpath(skillDirPath).catch(() => skillDirPath)
+              const skillMdPath = path.join(skillDirPath, SKILL_MD)
               try {
                 const raw = await fs.readFile(skillMdPath, "utf-8")
                 const { data: frontmatter } = matter(raw)
                 const skillName = entry.name
+                const canonicalPath = await fs.realpath(skillDirPath).catch(() => skillDirPath)
+                const scope = getScopeForPath(canonicalPath)
+                const supportingFiles = await listSupportingFiles(canonicalPath)
 
-                const existing = skillMap.get(skillName)
+                const existing = skillMap.get(canonicalPath)
                 if (existing) {
                   // Skill already seen from another agent - add this agent
                   if (!existing.agents.includes(agent.name)) {
                     existing.agents.push(agent.name)
                   }
                 } else {
-                  skillMap.set(skillName, {
+                  skillMap.set(canonicalPath, {
                     name: skillName,
                     description:
                       (frontmatter.description as string) ??
                       extractFirstLine(raw),
                     filePath: skillMdPath,
+                    canonicalPath,
                     agents: [agent.name],
+                    scope,
+                    projectName:
+                      scope === "project" ? getProjectNameForPath(canonicalPath) : null,
+                    hasSupportingFiles: supportingFiles.length > 0,
+                    supportingFiles,
                     metadata: frontmatter as Record<string, unknown>,
                     lock: lock.skills[skillName],
                   })
@@ -74,6 +169,17 @@ export function useInstalledSkills() {
           }
         }
 
+        const customScanPaths = settings.get<string[]>("scan.customPaths", [])
+        for (const customPath of customScanPaths) {
+          const resolvedRoot = path.resolve(customPath.replace(/^~(?=$|\/|\\)/, home))
+          const collected = await collectCustomSkills(resolvedRoot, lock)
+          for (const skill of collected) {
+            if (!skillMap.has(skill.canonicalPath)) {
+              skillMap.set(skill.canonicalPath, skill)
+            }
+          }
+        }
+
         if (cancelled) return
 
         const skills = Array.from(skillMap.values()).sort((a, b) =>
@@ -103,6 +209,75 @@ export function useInstalledSkills() {
   }, [installedLoading])
 }
 
+async function collectCustomSkills(
+  rootPath: string,
+  lock: SkillLockFile,
+): Promise<EnrichedSkill[]> {
+  const results: EnrichedSkill[] = []
+
+  async function maybeCollect(skillDir: string, scope: "project" | "custom") {
+    const skillMdPath = path.join(skillDir, SKILL_MD)
+    try {
+      const raw = await fs.readFile(skillMdPath, "utf-8")
+      const { data: frontmatter } = matter(raw)
+      const canonicalPath = await fs.realpath(skillDir).catch(() => skillDir)
+      const folderName = path.basename(skillDir)
+      const supportingFiles = await listSupportingFiles(canonicalPath)
+      results.push({
+        name: String((frontmatter.name as string) ?? folderName),
+        description:
+          (frontmatter.description as string) ?? extractFirstLine(raw),
+        filePath: skillMdPath,
+        canonicalPath,
+        agents: [],
+        scope,
+        projectName:
+          scope === "project" ? getProjectNameForPath(canonicalPath) : null,
+        hasSupportingFiles: supportingFiles.length > 0,
+        supportingFiles,
+        metadata: frontmatter as Record<string, unknown>,
+        lock: lock.skills[folderName],
+      })
+    } catch {
+      // ignore
+    }
+  }
+
+  await maybeCollect(rootPath, "custom")
+
+  let entries: Array<{ name: string; isDirectory: () => boolean }> = []
+  try {
+    entries = await fs.readdir(rootPath, { withFileTypes: true })
+  } catch {
+    return results
+  }
+
+  for (const entry of entries) {
+    if (!entry.isDirectory()) continue
+    await maybeCollect(path.join(rootPath, entry.name), "custom")
+  }
+
+  for (const entry of entries) {
+    if (!entry.isDirectory()) continue
+    const projectRoot = path.join(rootPath, entry.name)
+    for (const probe of PROJECT_PROBES) {
+      const probeDir = path.join(projectRoot, probe)
+      let probeEntries: Array<{ name: string; isDirectory: () => boolean }> = []
+      try {
+        probeEntries = await fs.readdir(probeDir, { withFileTypes: true })
+      } catch {
+        continue
+      }
+      for (const skillEntry of probeEntries) {
+        if (!skillEntry.isDirectory()) continue
+        await maybeCollect(path.join(probeDir, skillEntry.name), "project")
+      }
+    }
+  }
+
+  return results
+}
+
 /** Extracts the first non-empty, non-heading line from markdown content. */
 function extractFirstLine(content: string): string {
   const lines = content.split("\n")

package/src/data/use-search.ts

@@ -1,5 +1,5 @@
 import { useState, useEffect, useRef, useCallback } from "react"
-import { fetchCatalog, searchSkills, type CatalogSkill, type SearchMode } from "./api-client.js"
+import { searchSkills, type CatalogSkill } from "./api-client.js"
 
 const DEBOUNCE_MS = 300
 const PAGE_SIZE = 20
@@ -11,35 +11,28 @@ interface UseSearchResult {
   total: number
   hasMore: boolean
   loadMore: () => void
-  remainingSearches: number | null
 }
 
 /**
  * Hook that manages search state with debounce and pagination.
- * - When query is empty, loads the catalog with pagination
+ * - When query is empty, loads popular skills
  * - When query is provided, searches after 300ms debounce
- * - Supports keyword and semantic search modes
  */
-export function useSearch(
-  query: string,
-  mode: SearchMode,
-  token?: string | null
-): UseSearchResult {
+export function useSearch(query: string): UseSearchResult {
   const [results, setResults] = useState<CatalogSkill[]>([])
   const [loading, setLoading] = useState(false)
   const [error, setError] = useState<string | null>(null)
   const [total, setTotal] = useState(0)
   const [offset, setOffset] = useState(0)
-  const [remainingSearches, setRemainingSearches] = useState<number | null>(null)
 
   const timerRef = useRef<ReturnType<typeof setTimeout> | null>(null)
 
-  // Reset pagination when query or mode changes
+  // Reset pagination when query changes
   useEffect(() => {
     setResults([])
     setOffset(0)
     setError(null)
-  }, [query, mode])
+  }, [query])
 
   useEffect(() => {
     if (timerRef.current) {
@@ -52,19 +45,10 @@ export function useSearch(
       setError(null)
 
       try {
-        if (query.trim()) {
-          const data = await searchSkills(query, mode, token)
-          setResults(data.skills)
-          setTotal(data.total)
-          if (data.remainingSearches !== undefined) {
-            setRemainingSearches(data.remainingSearches)
-          }
-        } else {
-          const data = await fetchCatalog(PAGE_SIZE, 0)
-          setResults(data.skills)
-          setTotal(data.total)
-          setOffset(PAGE_SIZE)
-        }
+        const data = await searchSkills(query, PAGE_SIZE)
+        setResults(data.skills)
+        setTotal(data.total)
+        setOffset(PAGE_SIZE)
       } catch (err) {
         const msg = err instanceof Error ? err.message : String(err)
         if (!msg.includes("abort")) {
@@ -86,17 +70,17 @@ export function useSearch(
         clearTimeout(timerRef.current)
       }
     }
-  }, [query, mode, token])
+  }, [query])
 
   const loadMore = useCallback(async () => {
-    if (query.trim() || loading) return
-    if (results.length >= total) return
+    if (loading) return
+    if (results.length >= total && total > 0) return
 
     setLoading(true)
     try {
-      const data = await fetchCatalog(PAGE_SIZE, offset)
+      const data = await searchSkills(query, PAGE_SIZE, offset)
       setResults((prev) => [...prev, ...data.skills])
-      setTotal(data.total)
+      setTotal((prev) => prev + data.total)
       setOffset((prev) => prev + PAGE_SIZE)
     } catch (err) {
       const msg = err instanceof Error ? err.message : String(err)
@@ -113,6 +97,5 @@ export function useSearch(
     total,
     hasMore: results.length < total,
     loadMore,
-    remainingSearches,
   }
 }

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

@@ -1,10 +1,13 @@
 import { useCallback } from "react"
+import { exec as execCb } from "node:child_process"
+import { promisify } from "node:util"
 import { useStore, useDispatch } from "../store/context.js"
-import type { EnrichedSkill } from "../store/types.js"
+import { useDb } from "../db/context.js"
+import type { EnrichedSkill, Action } 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 { cleanupTempDir, fetchTreeSha } from "../../../cli/src/core/git.js"
 import { discoverSkills } from "../../../cli/src/core/skill-discovery.js"
 import {
   installSkillForAgent,
@@ -15,12 +18,11 @@ import {
 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"
+import type { Skill, AgentConfig } from "../../../cli/src/types.js"
 
 interface UseSkillActionsResult {
   installSkill: (skill: EnrichedSkill) => Promise<void>
@@ -36,9 +38,12 @@ interface UseSkillActionsResult {
 export function useSkillActions(): UseSkillActionsResult {
   const state = useStore()
   const dispatch = useDispatch()
+  const { settings } = useDb()
 
   /**
-   * Install a skill from its source (GitHub URL, SkillsGate slug, or install command).
+   * Install a skill from its source.
+   * For public skills (with a source in owner/repo format), runs `npx skills add`.
+   * For private skills, uses the existing download flow.
    */
   const installSkill = useCallback(async (skill: EnrichedSkill) => {
     dispatch({
@@ -59,7 +64,16 @@ export function useSkillActions(): UseSkillActionsResult {
 
       const source = parseSource(sourceStr)
 
-      // Detect installed agents to install to
+      // Public skills (owner/repo format): use `npx skills add`
+      if (source.type === "github" || isOwnerRepoFormat(sourceStr)) {
+        const repo = source.type === "github"
+          ? `${source.owner}/${source.repo}`
+          : sourceStr
+        await runSkillsAdd(repo, dispatch)
+        return
+      }
+
+      // Private skills: use the existing download flow
       const installedAgents = await detectInstalledAgents()
       if (installedAgents.length === 0) {
         dispatch({
@@ -69,21 +83,33 @@ export function useSkillActions(): UseSkillActionsResult {
         return
       }
 
+      const defaultAgents = settings.get<string[]>("install.defaultAgents", [])
+      const mirrorAgents = settings.get<string[]>("sync.mirrorAgents", [])
+      const preferredNames =
+        defaultAgents.length > 0
+          ? Array.from(new Set([...defaultAgents, ...mirrorAgents]))
+          : Array.from(
+              new Set([
+                ...installedAgents.map((agent) => agent.name),
+                ...mirrorAgents,
+              ]),
+            )
+      const targetAgents = installedAgents.filter((agent) =>
+        preferredNames.includes(agent.name),
+      )
+
       let tmpDir: string
       if (source.type === "skillsgate") {
-        // Download from SkillsGate API
+        // Download from private 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
+        // Discover skills in the downloaded directory
         const skills = await discoverSkills(tmpDir, source.subpath)
 
         if (skills.length === 0) {
@@ -112,7 +138,7 @@ export function useSkillActions(): UseSkillActionsResult {
 
         for (const skillToInstall of targetSkills) {
           // Install to all detected agents
-          for (const agent of installedAgents) {
+          for (const agent of targetAgents) {
             const result = await installSkillForAgent(
               skillToInstall,
               agent,
@@ -141,7 +167,7 @@ export function useSkillActions(): UseSkillActionsResult {
           type: "SHOW_NOTIFICATION",
           notification: {
             type: "success",
-            message: `Installed ${targetSkills.length} skill(s): ${skillNames} to ${installedAgents.length} agent(s)`,
+            message: `Installed ${targetSkills.length} skill(s): ${skillNames} to ${targetAgents.length} agent(s)`,
           },
         })
       } finally {
@@ -303,9 +329,49 @@ export function useSkillActions(): UseSkillActionsResult {
 
 // ---------- Helpers ----------
 
+const execAsync = promisify(execCb)
+
+/**
+ * Checks if a string matches the owner/repo format (e.g. "vercel/skills").
+ */
+function isOwnerRepoFormat(str: string): boolean {
+  return /^[a-zA-Z0-9_.-]+\/[a-zA-Z0-9_.-]+$/.test(str)
+}
+
+/**
+ * Runs `npx skills add <source> --all -y` as a child process to install
+ * all skills from a public repository.
+ */
+async function runSkillsAdd(
+  source: string,
+  dispatch: (action: Action) => void
+): Promise<void> {
+  try {
+    await execAsync(
+      `npx skills add ${source} --all -y`,
+      { timeout: 60_000 }
+    )
+
+    dispatch({ type: "REFRESH_SKILLS" })
+    dispatch({
+      type: "SHOW_NOTIFICATION",
+      notification: {
+        type: "success",
+        message: `Installed skills from ${source}`,
+      },
+    })
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err)
+    dispatch({
+      type: "SHOW_NOTIFICATION",
+      notification: { type: "error", message: `Install failed: ${msg}` },
+    })
+  }
+}
+
 /**
  * Resolves the source string for a skill from its metadata.
- * Checks: lock.source, metadata.githubUrl, metadata.installCommand
+ * Checks: lock.source, metadata.source, metadata.githubUrl, metadata.installCommand
  */
 function resolveSource(skill: EnrichedSkill): string | null {
   // From lock file entry
@@ -313,17 +379,20 @@ function resolveSource(skill: EnrichedSkill): string | null {
     return skill.lock.source
   }
 
-  // From metadata (catalog skills)
+  // From metadata (catalog skills -- owner/repo format)
   const meta = skill.metadata
+  if (meta?.source && typeof meta.source === "string") {
+    return meta.source
+  }
+
   if (meta?.githubUrl && typeof meta.githubUrl === "string") {
     return meta.githubUrl
   }
 
-  // From install command (e.g. "skillsgate add @user/slug")
+  // From install command (e.g. "skills add <source>")
   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+(.+)/)
+    const match = cmd.match(/skills?\s+(?:add|install)\s+(.+)/)
     if (match) {
       return match[1].trim()
     }

package/src/db/skills.ts

@@ -135,4 +135,28 @@ export class RemoteSkillStore {
       .get(id) as { content: string | null } | null
     return row?.content ?? null
   }
+
+  getByPath(serverId: string, remotePath: string): RemoteSkill | null {
+    const row = this.db
+      .query(
+        "SELECT * FROM remote_skills WHERE server_id = ? AND remote_path = ? LIMIT 1",
+      )
+      .get(serverId, remotePath) as SkillRow | null
+    return row ? rowToSkill(row) : null
+  }
+
+  updateContent(
+    serverId: string,
+    remotePath: string,
+    content: string,
+    contentHash: string,
+  ): void {
+    this.db
+      .query(
+        `UPDATE remote_skills
+         SET content = ?, content_hash = ?, synced_at = datetime('now')
+         WHERE server_id = ? AND remote_path = ?`,
+      )
+      .run(content, contentHash, serverId, remotePath)
+  }
 }

package/src/db/ssh.ts

@@ -1,4 +1,4 @@
-import { spawn } from "node:child_process"
+import { spawn, spawnSync } from "node:child_process"
 import os from "node:os"
 import path from "node:path"
 import fs from "node:fs"
@@ -95,6 +95,50 @@ export async function testConnection(
   }
 }
 
+export async function readRemoteFile(
+  server: RemoteServer,
+  remotePath: string,
+): Promise<string> {
+  const escaped = `'${remotePath.replace(/'/g, "'\\''")}'`
+  const result = await sshExec(server, `cat ${escaped}`)
+  if (result.exitCode !== 0) {
+    throw new Error(result.stderr.trim() || "Failed to read remote file")
+  }
+  return result.stdout
+}
+
+export async function writeRemoteFile(
+  server: RemoteServer,
+  remotePath: string,
+  content: string,
+): Promise<void> {
+  await new Promise<void>((resolve, reject) => {
+    const escaped = `'${remotePath.replace(/'/g, "'\\''")}'`
+    const command = `mkdir -p "$(dirname ${escaped})" && cat > ${escaped}`
+    const args = [...buildSshArgs(server), command]
+    const proc = spawn("ssh", args, {
+      stdio: ["pipe", "pipe", "pipe"],
+    })
+
+    let stderr = ""
+    proc.stderr.on("data", (data: Buffer) => {
+      stderr += data.toString("utf-8")
+    })
+
+    proc.on("error", (err) => reject(new Error(err.message)))
+    proc.on("close", (code) => {
+      if ((code ?? 1) === 0) {
+        resolve()
+      } else {
+        reject(new Error(stderr.trim() || `SSH exited with code ${code ?? 1}`))
+      }
+    })
+
+    proc.stdin.write(content, "utf-8")
+    proc.stdin.end()
+  })
+}
+
 // ---------- Remote Skill Scanner ----------
 
 function shellQuotePath(remotePath: string): string {

package/src/store/types.ts

@@ -20,8 +20,16 @@ export interface EnrichedSkill {
   name: string
   description: string
   filePath: string
+  canonicalPath: string
   /** Which agents have this skill installed (by agent name) */
   agents: AgentType[]
+  scope: "global" | "project" | "custom"
+  projectName: string | null
+  hasSupportingFiles: boolean
+  supportingFiles: Array<{
+    relativePath: string
+    size: number
+  }>
   /** Frontmatter metadata from the SKILL.md */
   metadata: Record<string, unknown>
   /** Lock file entry if tracked */

package/src/types/bun-sqlite.d.ts

@@ -0,0 +1,12 @@
+declare module "bun:sqlite" {
+  export class Database {
+    constructor(path: string)
+    query(sql: string): {
+      all(...params: unknown[]): unknown[]
+      get(...params: unknown[]): unknown
+      run(...params: unknown[]): { changes: number }
+    }
+    exec(sql: string): void
+    close(): void
+  }
+}

package/src/views/add-server.tsx

@@ -201,16 +201,16 @@ export function AddServerView({ editServerId, onServerCountChange }: AddServerVi
             <input
               placeholder={field.placeholder}
               focused={i === focusedFieldIndex && !state.showHelp && !saving}
-              defaultValue={values[field.name]}
+              {...({ defaultValue: values[field.name] } as any)}
               onInput={(value: string) => handleFieldChange(field.name, value)}
-              onSubmit={() => {
+              onSubmit={(() => {
                 // When pressing Enter on the last field, save
                 if (i === FIELDS.length - 1) {
                   handleSave()
                 } else {
                   setFocusedFieldIndex(i + 1)
                 }
-              }}
+              }) as any}
             />
           </box>
         </box>