Merge pull request #7 from derekross/feature/skills-library

feat: skills.sh library integration

Author: derekross

package.json

@@ -1,6 +1,6 @@
 {
   "name": "onyx",
-  "version": "0.7.0",
+  "version": "0.8.0",
   "description": "Open source knowledge base and note-taking app",
   "type": "module",
   "scripts": {

src-tauri/Cargo.lock

@@ -1,6 +1,6 @@
 [package]
 name = "onyx"
-version = "0.7.0"
+version = "0.8.0"
 description = "Open source knowledge base and note-taking app"
 authors = ["you"]
 license = "MIT"

src-tauri/Cargo.toml

@@ -1480,6 +1480,49 @@ fn skill_read_file(skill_id: String, file_name: String) -> Result<String, String
     fs::read_to_string(&file_path).map_err(|e| e.to_string())
 }
 
+#[tauri::command]
+async fn fetch_skills_sh(limit: Option<u32>) -> Result<String, String> {
+    let limit = limit.unwrap_or(500); // Fetch up to 500 skills by default
+    let url = format!("https://skills.sh/api/skills?limit={}", limit);
+    
+    let client = reqwest::Client::new();
+    let response = client
+        .get(&url)
+        .timeout(Duration::from_secs(30))
+        .send()
+        .await
+        .map_err(|e| format!("Failed to fetch skills.sh: {}", e))?;
+
+    if !response.status().is_success() {
+        return Err(format!("skills.sh returned status: {}", response.status()));
+    }
+
+    response
+        .text()
+        .await
+        .map_err(|e| format!("Failed to read response: {}", e))
+}
+
+#[tauri::command]
+async fn fetch_skill_file(url: String) -> Result<String, String> {
+    let client = reqwest::Client::new();
+    let response = client
+        .get(&url)
+        .timeout(Duration::from_secs(30))
+        .send()
+        .await
+        .map_err(|e| format!("Failed to fetch skill file: {}", e))?;
+
+    if !response.status().is_success() {
+        return Err(format!("Failed to fetch skill file: status {}", response.status()));
+    }
+
+    response
+        .text()
+        .await
+        .map_err(|e| format!("Failed to read skill file: {}", e))
+}
+
 // Keyring commands for secure credential storage (desktop only)
 #[cfg(not(target_os = "android"))]
 mod keyring_commands {
@@ -1661,6 +1704,8 @@ pub fn run() {
             skill_delete,
             skill_list_installed,
             skill_read_file,
+            fetch_skills_sh,
+            fetch_skill_file,
             get_platform_info,
             opencode_installer::check_opencode_installed,
             opencode_installer::get_opencode_install_path,

src-tauri/src/lib.rs

@@ -1,7 +1,7 @@
 {
   "$schema": "../node_modules/@tauri-apps/cli/config.schema.json",
   "productName": "Onyx",
-  "version": "0.7.0",
+  "version": "0.8.0",
   "identifier": "com.onyxnotes.dev",
   "build": {
     "frontendDist": "../dist",

src-tauri/tauri.conf.json

@@ -0,0 +1,285 @@
+/**
+ * Skills library integration
+ * 
+ * Provides access to:
+ * 1. Curated skills from onyx-skills repo (recommended)
+ * 2. Full skills.sh ecosystem (browse library)
+ */
+
+import { invoke } from '@tauri-apps/api/core';
+
+// Skills.sh API types
+export interface SkillsShSkill {
+  id: string;
+  name: string;
+  installs: number;
+  topSource: string; // Format: "owner/repo"
+}
+
+export interface SkillsShResponse {
+  skills: SkillsShSkill[];
+  hasMore: boolean;
+}
+
+// Extended skill info for UI
+export interface SkillInfo {
+  id: string;
+  name: string;
+  description: string;
+  icon: string;
+  category: string;
+  dependencies?: string[];
+  files: string[];
+  isCustom?: boolean;
+  // skills.sh specific fields
+  source?: 'onyx' | 'skillssh';
+  installs?: number;
+  topSource?: string; // "owner/repo"
+}
+
+export interface SkillState {
+  enabled: boolean;
+  installed: boolean;
+  downloading: boolean;
+}
+
+// Cache for skills.sh data
+interface SkillsShCache {
+  data: SkillsShSkill[];
+  timestamp: number;
+}
+
+const CACHE_TTL_MS = 5 * 60 * 1000; // 5 minutes
+
+let skillsShCache: SkillsShCache | null = null;
+
+/**
+ * Fetch skills leaderboard from skills.sh API
+ * Uses Tauri backend to bypass CORS restrictions
+ * Returns cached data if available and not expired
+ */
+export async function fetchSkillsShLeaderboard(forceRefresh = false): Promise<SkillsShSkill[]> {
+  // Check cache
+  if (!forceRefresh && skillsShCache && Date.now() - skillsShCache.timestamp < CACHE_TTL_MS) {
+    return skillsShCache.data;
+  }
+
+  try {
+    // Use Tauri backend to bypass CORS
+    const responseText = await invoke<string>('fetch_skills_sh');
+    const data: SkillsShResponse = JSON.parse(responseText);
+    
+    // Update cache
+    skillsShCache = {
+      data: data.skills,
+      timestamp: Date.now(),
+    };
+
+    return data.skills;
+  } catch (err) {
+    console.error('Failed to fetch skills.sh leaderboard:', err);
+    // Return cached data if available, even if expired
+    if (skillsShCache) {
+      return skillsShCache.data;
+    }
+    throw err;
+  }
+}
+
+/**
+ * Search/filter skills.sh skills
+ */
+export function searchSkillsSh(skills: SkillsShSkill[], query: string): SkillsShSkill[] {
+  if (!query.trim()) {
+    return skills;
+  }
+
+  const lowerQuery = query.toLowerCase();
+  return skills.filter(skill => 
+    skill.id.toLowerCase().includes(lowerQuery) ||
+    skill.name.toLowerCase().includes(lowerQuery) ||
+    skill.topSource.toLowerCase().includes(lowerQuery)
+  );
+}
+
+/**
+ * Sort skills by different criteria
+ */
+export type SkillsSortOption = 'popular' | 'name' | 'source';
+
+export function sortSkillsSh(skills: SkillsShSkill[], sortBy: SkillsSortOption): SkillsShSkill[] {
+  const sorted = [...skills];
+  switch (sortBy) {
+    case 'popular':
+      return sorted.sort((a, b) => b.installs - a.installs);
+    case 'name':
+      return sorted.sort((a, b) => a.name.localeCompare(b.name));
+    case 'source':
+      return sorted.sort((a, b) => a.topSource.localeCompare(b.topSource));
+    default:
+      return sorted;
+  }
+}
+
+/**
+ * Format install count for display (e.g., 27165 -> "27.2K")
+ */
+export function formatInstallCount(count: number): string {
+  if (count >= 1000000) {
+    return `${(count / 1000000).toFixed(1)}M`;
+  }
+  if (count >= 1000) {
+    return `${(count / 1000).toFixed(1)}K`;
+  }
+  return count.toString();
+}
+
+/**
+ * Get GitHub raw URL for a skill file
+ * skills.sh skills are stored at: https://raw.githubusercontent.com/{owner}/{repo}/main/skills/{skill-id}/SKILL.md
+ */
+export function getSkillFileUrl(topSource: string, skillId: string, fileName: string): string {
+  const [owner, repo] = topSource.split('/');
+  return `https://raw.githubusercontent.com/${owner}/${repo}/main/skills/${skillId}/${fileName}`;
+}
+
+/**
+ * Get GitHub URL for viewing a skill on GitHub
+ */
+export function getSkillGitHubUrl(topSource: string, skillId: string): string {
+  const [owner, repo] = topSource.split('/');
+  return `https://github.com/${owner}/${repo}/tree/main/skills/${skillId}`;
+}
+
+/**
+ * Download and install a skill from skills.sh
+ * Uses Tauri backend to bypass CORS restrictions
+ */
+export async function installSkillFromSkillsSh(skill: SkillsShSkill): Promise<void> {
+  const skillUrl = getSkillFileUrl(skill.topSource, skill.id, 'SKILL.md');
+  
+  try {
+    // Download SKILL.md using Tauri backend to bypass CORS
+    const content = await invoke<string>('fetch_skill_file', { url: skillUrl });
+    
+    // Save the skill file using Tauri backend
+    await invoke('skill_save_file', {
+      skillId: skill.id,
+      fileName: 'SKILL.md',
+      content,
+    });
+  } catch (err) {
+    console.error(`Failed to install skill ${skill.id}:`, err);
+    throw err;
+  }
+}
+
+/**
+ * Check if a skill is installed
+ */
+export async function isSkillInstalled(skillId: string): Promise<boolean> {
+  try {
+    return await invoke<boolean>('skill_is_installed', { skillId });
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Delete an installed skill
+ */
+export async function deleteSkill(skillId: string): Promise<void> {
+  await invoke('skill_delete', { skillId });
+}
+
+/**
+ * Get list of all installed skill IDs
+ */
+export async function getInstalledSkillIds(): Promise<string[]> {
+  return await invoke<string[]>('skill_list_installed');
+}
+
+/**
+ * Read a skill file content
+ */
+export async function readSkillFile(skillId: string, fileName: string): Promise<string> {
+  return await invoke<string>('skill_read_file', { skillId, fileName });
+}
+
+/**
+ * Parse skill name from SKILL.md content
+ */
+export function parseSkillName(content: string, fallbackId: string): string {
+  // Try to find a # heading
+  const headingMatch = content.match(/^#\s+(.+)$/m);
+  if (headingMatch) {
+    return headingMatch[1].trim();
+  }
+  
+  // Try to find a title: metadata
+  const titleMatch = content.match(/^title:\s*(.+)$/mi);
+  if (titleMatch) {
+    return titleMatch[1].trim();
+  }
+  
+  // Use ID as fallback, converting kebab-case to Title Case
+  return fallbackId
+    .split('-')
+    .map(word => word.charAt(0).toUpperCase() + word.slice(1))
+    .join(' ');
+}
+
+/**
+ * Parse skill description from SKILL.md content
+ */
+export function parseSkillDescription(content: string): string {
+  // Try to find a description: metadata
+  const descMatch = content.match(/^description:\s*(.+)$/mi);
+  if (descMatch) {
+    return descMatch[1].trim();
+  }
+  
+  // Try to find the first paragraph after the heading
+  const lines = content.split('\n');
+  let foundHeading = false;
+  for (const line of lines) {
+    if (line.startsWith('#')) {
+      foundHeading = true;
+      continue;
+    }
+    if (foundHeading && line.trim() && !line.startsWith('#') && !line.startsWith('-') && !line.startsWith('*')) {
+      return line.trim().slice(0, 150);
+    }
+  }
+  
+  return 'A skill for AI agents';
+}
+
+/**
+ * Clear the skills.sh cache
+ */
+export function clearSkillsShCache(): void {
+  skillsShCache = null;
+}
+
+/**
+ * Get unique sources (owners) from skills list for filtering
+ */
+export function getUniqueSources(skills: SkillsShSkill[]): string[] {
+  const sources = new Set<string>();
+  for (const skill of skills) {
+    const [owner] = skill.topSource.split('/');
+    sources.add(owner);
+  }
+  return Array.from(sources).sort();
+}
+
+/**
+ * Filter skills by source/owner
+ */
+export function filterBySource(skills: SkillsShSkill[], source: string): SkillsShSkill[] {
+  if (!source || source === 'all') {
+    return skills;
+  }
+  return skills.filter(skill => skill.topSource.startsWith(source + '/'));
+}