@aion0/forge 0.4.16 → 0.5.0

package/lib/skills.ts

@@ -1,25 +1,17 @@
 /**
- * Skills & Commands marketplace — sync from registry, install/uninstall.
- *
- * Skills:   ~/.claude/skills/<name>/  (directory with SKILL.md + support files)
- * Commands: ~/.claude/commands/<name>.md  (single .md file)
- *
- * Install = download all files from GitHub repo directory → write to local.
- * No tar.gz — direct file sync via GitHub raw URLs.
- * Version tracking — compare registry version with installed version for update detection.
+ * Skills Marketplace — sync, install, uninstall from remote registry.
  */
 
+import { existsSync, readdirSync, statSync, readFileSync, writeFileSync, mkdirSync, rmSync, cpSync } from 'node:fs';
+import { join, dirname, basename, relative, sep } from 'node:path';
+import { homedir } from 'node:os';
 import { getDb } from '@/src/core/db/database';
 import { getDbPath } from '@/src/config';
 import { loadSettings } from './settings';
-import { existsSync, mkdirSync, writeFileSync, unlinkSync, readdirSync, rmSync, readFileSync } from 'node:fs';
-import { join } from 'node:path';
-import { createHash } from 'node:crypto';
-import { getClaudeDir } from './dirs';
 
-export type ItemType = 'skill' | 'command';
+type ItemType = 'skill' | 'command';
 
-export interface SkillItem {
+interface SkillItem {
   name: string;
   type: ItemType;
   displayName: string;
@@ -28,35 +20,32 @@ export interface SkillItem {
   version: string;
   tags: string[];
   score: number;
-  rating: number;       // 0-5 star rating from registry
+  rating: number;
   sourceUrl: string;
   installedGlobal: boolean;
   installedProjects: string[];
-  installedVersion: string;  // version currently installed (empty if not installed)
-  hasUpdate: boolean;         // true if registry version > installed version
-  deletedRemotely: boolean;   // true if removed from remote registry but still installed locally
+  installedVersion: string;
+  hasUpdate: boolean;
+  deletedRemotely: boolean;
 }
 
 function db() {
   return getDb(getDbPath());
 }
 
-const GLOBAL_SKILLS_DIR = join(getClaudeDir(), 'skills');
-const GLOBAL_COMMANDS_DIR = join(getClaudeDir(), 'commands');
-
 function getBaseUrl(): string {
   const settings = loadSettings();
   return settings.skillsRepoUrl || 'https://raw.githubusercontent.com/aiwatching/forge-skills/main';
 }
 
-function getRepoInfo(): string {
-  const baseUrl = getBaseUrl();
-  const match = baseUrl.match(/github\.com\/([^/]+\/[^/]+)/);
-  return match ? match[1] : 'aiwatching/forge-skills';
+function getRepoInfo(): { owner: string; repo: string; branch: string } {
+  const url = getBaseUrl();
+  const match = url.match(/github\.com\/([^/]+)\/([^/]+)(?:\/tree\/([^/]+))?/) ||
+                url.match(/raw\.githubusercontent\.com\/([^/]+)\/([^/]+)\/([^/]+)/);
+  if (match) return { owner: match[1], repo: match[2], branch: match[3] || 'main' };
+  return { owner: 'aiwatching', repo: 'forge-skills', branch: 'main' };
 }
 
-// ─── Version comparison ──────────────────────────────────────
-
 function compareVersions(a: string, b: string): number {
   const pa = (a || '0.0.0').split('.').map(Number);
   const pb = (b || '0.0.0').split('.').map(Number);
@@ -67,131 +56,74 @@ function compareVersions(a: string, b: string): number {
   return 0;
 }
 
-/** Read installed version from info.json (skills) or return DB version (commands) */
-function getInstalledVersion(name: string, type: string, basePath?: string): string {
-  if (type === 'skill') {
-    const dir = basePath
-      ? join(basePath, '.claude', 'skills', name)
-      : join(GLOBAL_SKILLS_DIR, name);
-    const infoPath = join(dir, 'info.json');
-    try {
-      const info = JSON.parse(readFileSync(infoPath, 'utf-8'));
-      return info.version || '';
-    } catch { return ''; }
-  }
-  // Commands don't have version files — use DB installed_version
-  const row = db().prepare('SELECT installed_version FROM skills WHERE name = ?').get(name) as any;
-  return row?.installed_version || '';
-}
+// ─── Sync ─────────────────────────────────────────────────────
 
-// ─── Sync from registry ──────────────────────────────────────
+/** Max info.json enrichments per sync (incremental) */
+const ENRICH_BATCH_SIZE = 10;
 
-export async function syncSkills(): Promise<{ synced: number; error?: string }> {
+export async function syncSkills(): Promise<{ synced: number; enriched: number; total?: number; remaining?: number; error?: string }> {
   console.log('[skills] Syncing from registry...');
   const baseUrl = getBaseUrl();
 
   try {
+    // Step 1: Fetch registry.json (always fresh)
     const controller = new AbortController();
     const timeout = setTimeout(() => controller.abort(), 10000);
-    const res = await fetch(`${baseUrl}/registry.json`, {
+    const cacheBust = `_t=${Date.now()}`;
+    const res = await fetch(`${baseUrl}/registry.json?${cacheBust}`, {
       signal: controller.signal,
-      headers: { 'Accept': 'application/json' },
+      headers: { 'Accept': 'application/json', 'Cache-Control': 'no-cache' },
     });
     clearTimeout(timeout);
 
-    if (!res.ok) return { synced: 0, error: `Registry fetch failed: ${res.status}` };
+    if (!res.ok) return { synced: 0, enriched: 0, error: `Registry fetch failed: ${res.status}` };
 
     const data = await res.json();
 
-    // Support both v1 (flat skills array) and v2 (separate skills + commands)
-    let items: any[] = [];
+    // Parse registry items (v1 + v2 support)
+    let rawItems: any[] = [];
     if (data.version === 2) {
-      const rawItems = [
+      rawItems = [
         ...(data.skills || []).map((s: any) => ({ ...s, type: s.type || 'skill' })),
         ...(data.commands || []).map((c: any) => ({ ...c, type: c.type || 'command' })),
       ];
-      // Always enrich from info.json for latest rating/score/version
-      items = await Promise.all(rawItems.map(async (s: any) => {
-        try {
-          const repoDir = s.type === 'skill' ? 'skills' : 'commands';
-          let infoRes = await fetch(`${baseUrl}/${repoDir}/${s.name}/info.json`, { signal: AbortSignal.timeout(5000) });
-          if (!infoRes.ok) {
-            const altDir = s.type === 'skill' ? 'commands' : 'skills';
-            infoRes = await fetch(`${baseUrl}/${altDir}/${s.name}/info.json`, { signal: AbortSignal.timeout(5000) });
-          }
-          if (infoRes.ok) {
-            const info = await infoRes.json();
-            return {
-              ...s,
-              version: info.version || s.version,
-              score: info.score ?? s.score ?? 0,
-              rating: info.rating ?? s.rating ?? 0,
-              description: info.description || s.description,
-            };
-          }
-        } catch {}
-        return s;
-      }));
     } else {
-      // v1: enrich from info.json in parallel
-      const rawItems = data.skills || [];
-      const enriched = await Promise.all(rawItems.map(async (s: any) => {
-        // Fetch info.json for metadata and type
-        try {
-          let infoRes = await fetch(`${baseUrl}/skills/${s.name}/info.json`, { signal: AbortSignal.timeout(5000) });
-          if (!infoRes.ok) {
-            infoRes = await fetch(`${baseUrl}/commands/${s.name}/info.json`, { signal: AbortSignal.timeout(5000) });
-          }
-          if (infoRes.ok) {
-            const info = await infoRes.json();
-            return {
-              ...s,
-              type: info.type || s.type || 'command',
-              display_name: info.display_name || s.display_name,
-              description: info.description || s.description,
-              version: info.version || s.version,
-              tags: info.tags || s.tags,
-              score: info.score ?? s.score,
-              rating: info.rating ?? s.rating ?? 0,
-            };
-          }
-        } catch {}
-        return { ...s, type: s.type || 'command' };
-      }));
-      items = enriched;
+      rawItems = (data.skills || []).map((s: any) => ({ ...s, type: s.type || 'command' }));
     }
 
-    const stmt = db().prepare(`
+    // Step 2: Upsert all items from registry.json directly (fast, no extra fetch)
+    const upsertStmt = db().prepare(`
       INSERT OR REPLACE INTO skills (name, type, display_name, description, author, version, tags, score, rating, source_url, archive, synced_at,
         installed_global, installed_projects, installed_version)
-      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, datetime('now'),
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?,
+        COALESCE((SELECT synced_at FROM skills WHERE name = ?), datetime('now')),
         COALESCE((SELECT installed_global FROM skills WHERE name = ?), 0),
         COALESCE((SELECT installed_projects FROM skills WHERE name = ?), '[]'),
         COALESCE((SELECT installed_version FROM skills WHERE name = ?), ''))
     `);
 
     const tx = db().transaction(() => {
-      for (const s of items) {
-        stmt.run(
-          s.name, s.type || 'skill',
-          s.display_name, s.description || '',
-          s.author?.name || '', s.version || '', JSON.stringify(s.tags || []),
-          s.score || 0, s.rating || 0, s.source?.url || '',
-          '', // archive field (unused now, kept for compat)
-          s.name, s.name, s.name
+      for (const s of rawItems) {
+        upsertStmt.run(
+          s.name || '', s.type || 'skill',
+          s.display_name || '', s.description || '',
+          (s.author?.name || s.author || '').toString(), s.version || '',
+          JSON.stringify(s.tags || []),
+          s.score ?? 0, s.rating ?? 0, s.source?.url || s.source_url || '',
+          '', // archive
+          s.name || '', s.name || '', s.name || '', s.name || ''
         );
       }
     });
     tx();
 
-    // Handle items no longer in registry
-    const registryNames = new Set(items.map(s => s.name));
+    // Step 3: Handle items no longer in registry
+    const registryNames = new Set(rawItems.map((s: any) => s.name));
     const dbItems = db().prepare('SELECT name, installed_global, installed_projects FROM skills').all() as any[];
     for (const row of dbItems) {
       if (!registryNames.has(row.name)) {
         const hasLocal = !!row.installed_global || JSON.parse(row.installed_projects || '[]').length > 0;
         if (hasLocal) {
-          // Still installed locally — mark as deleted remotely so the user can decide
           db().prepare('UPDATE skills SET deleted_remotely = 1 WHERE name = ?').run(row.name);
         } else {
           db().prepare('DELETE FROM skills WHERE name = ?').run(row.name);
@@ -199,10 +131,64 @@ export async function syncSkills(): Promise<{ synced: number; error?: string }>
       }
     }
 
-    console.log(`[skills] Synced ${items.length} items`);
-    return { synced: items.length };
+    // Step 4: Incremental enrichment — fetch info.json for oldest-synced items
+    // Pick items whose synced_at is oldest (or version changed since last enrich)
+    const staleItems = db().prepare(`
+      SELECT name, type, version FROM skills
+      WHERE deleted_remotely = 0
+      ORDER BY synced_at ASC
+      LIMIT ?
+    `).all(ENRICH_BATCH_SIZE) as any[];
+
+    let enriched = 0;
+    const enrichStmt = db().prepare(`
+      UPDATE skills SET
+        version = COALESCE(?, version),
+        tags = COALESCE(?, tags),
+        score = COALESCE(?, score),
+        rating = COALESCE(?, rating),
+        description = COALESCE(?, description),
+        synced_at = datetime('now')
+      WHERE name = ?
+    `);
+
+    await Promise.all(staleItems.map(async (s: any) => {
+      try {
+        const repoDir = s.type === 'skill' ? 'skills' : 'commands';
+        let infoRes = await fetch(`${baseUrl}/${repoDir}/${s.name}/info.json?${cacheBust}`, { signal: AbortSignal.timeout(5000) });
+        if (!infoRes.ok) {
+          const altDir = s.type === 'skill' ? 'commands' : 'skills';
+          infoRes = await fetch(`${baseUrl}/${altDir}/${s.name}/info.json?${cacheBust}`, { signal: AbortSignal.timeout(5000) });
+        }
+        if (infoRes.ok) {
+          const info = await infoRes.json();
+          enrichStmt.run(
+            info.version || null,
+            info.tags?.length ? JSON.stringify(info.tags) : null,
+            info.score ?? null,
+            info.rating ?? null,
+            info.description || null,
+            s.name
+          );
+          enriched++;
+        } else {
+          // No info.json — just update synced_at so it rotates to the back
+          db().prepare('UPDATE skills SET synced_at = datetime(\'now\') WHERE name = ?').run(s.name);
+        }
+      } catch {
+        // Timeout/error — update synced_at to avoid retrying immediately
+        db().prepare('UPDATE skills SET synced_at = datetime(\'now\') WHERE name = ?').run(s.name);
+      }
+    }));
+
+    const totalCount = (db().prepare('SELECT count(*) as c FROM skills WHERE deleted_remotely = 0').get() as any).c;
+    const remaining = totalCount - ENRICH_BATCH_SIZE; // approximate items not yet enriched this round
+    console.log(`[skills] Synced ${rawItems.length} items, enriched ${enriched}/${staleItems.length} from info.json`);
+    return { synced: rawItems.length, enriched, total: totalCount, remaining: Math.max(0, remaining) };
   } catch (e) {
-    return { synced: 0, error: e instanceof Error ? e.message : String(e) };
+    const msg = e instanceof Error ? e.message : String(e);
+    console.error(`[skills] Sync failed:`, msg);
+    return { synced: 0, enriched: 0, error: msg };
   }
 }
 
@@ -248,334 +234,225 @@ async function listRepoFiles(name: string, type: ItemType): Promise<{ path: stri
     if (!res.ok) return;
     const items = await res.json();
     if (!Array.isArray(items)) return;
-
     for (const item of items) {
-      const relPath = prefix ? `${prefix}/${item.name}` : item.name;
-      if (item.type === 'file') {
-        files.push({ path: relPath, download_url: item.download_url });
+      if (item.type === 'file' && item.download_url) {
+        files.push({ path: join(prefix, item.name), download_url: item.download_url });
       } else if (item.type === 'dir') {
-        await recurse(item.url, relPath);
+        await recurse(item.url, join(prefix, item.name));
       }
     }
   }
 
   // Try skills/ first, then commands/
-  await recurse(`https://api.github.com/repos/${repo}/contents/skills/${name}`, '');
-  if (files.length === 0) {
-    await recurse(`https://api.github.com/repos/${repo}/contents/commands/${name}`, '');
+  const dirs = type === 'skill' ? ['skills', 'commands'] : ['commands', 'skills'];
+  for (const dir of dirs) {
+    const url = `https://api.github.com/repos/${repo.owner}/${repo.repo}/contents/${dir}/${name}?ref=${repo.branch}`;
+    await recurse(url, '');
+    if (files.length > 0) return files;
   }
   return files;
 }
 
-/** Download all files to a local directory */
-async function downloadToDir(files: { path: string; download_url: string }[], destDir: string): Promise<void> {
-  if (!existsSync(destDir)) mkdirSync(destDir, { recursive: true });
+async function downloadFile(url: string): Promise<string> {
+  const res = await fetch(url);
+  if (!res.ok) throw new Error(`Download failed: ${res.status}`);
+  return res.text();
+}
 
-  for (const file of files) {
-    const filePath = join(destDir, file.path);
-    const fileDir = join(destDir, file.path.split('/').slice(0, -1).join('/'));
-    if (fileDir !== destDir && !existsSync(fileDir)) mkdirSync(fileDir, { recursive: true });
+// ─── Install ─────────────────────────────────────────────────
 
-    const res = await fetch(file.download_url);
-    if (!res.ok) continue;
-    const content = await res.text();
-    writeFileSync(filePath, content, 'utf-8');
-  }
+function getClaudeHome(): string {
+  const settings = loadSettings();
+  return settings.claudeHome || join(homedir(), '.claude');
 }
 
-// ─── Install ─────────────────────────────────────────────────
+function getSkillDir(name: string, type: ItemType, projectPath?: string): string {
+  const base = projectPath || getClaudeHome();
+  const subdir = type === 'skill' ? 'skills' : 'commands';
+  return join(base, '.claude', subdir, name);
+}
 
 export async function installGlobal(name: string): Promise<void> {
-  console.log(`[skills] Installing "${name}" globally`);
-  const row = db().prepare('SELECT type, version FROM skills WHERE name = ?').get(name) as any;
-  if (!row) throw new Error(`Not found: ${name}`);
-  const type: ItemType = row.type || 'skill';
-  const version = row.version || '';
+  const skill = db().prepare('SELECT * FROM skills WHERE name = ?').get(name) as any;
+  if (!skill) throw new Error(`Skill "${name}" not found`);
 
-  const files = await listRepoFiles(name, type);
+  const type: ItemType = skill.type || 'skill';
+  const claudeHome = getClaudeHome();
+  const subdir = type === 'skill' ? 'skills' : 'commands';
+  const targetDir = join(claudeHome, subdir, name);
 
-  if (type === 'skill') {
-    const dest = join(GLOBAL_SKILLS_DIR, name);
-    if (existsSync(dest)) rmSync(dest, { recursive: true });
-    await downloadToDir(files, dest);
-  } else {
-    // Command: download all files to commands/<name>/ directory
-    // If only a single .md, also copy as <name>.md directly for slash command registration
-    const dest = join(GLOBAL_COMMANDS_DIR);
-    if (!existsSync(dest)) mkdirSync(dest, { recursive: true });
-    const mdFiles = files.filter(f => f.path.endsWith('.md') && f.path !== 'info.json');
-    if (mdFiles.length === 1 && files.filter(f => f.path !== 'info.json').length === 1) {
-      // Single .md command — write directly as <name>.md
-      const res = await fetch(mdFiles[0].download_url);
-      if (res.ok) writeFileSync(join(dest, `${name}.md`), await res.text(), 'utf-8');
-    } else {
-      // Multi-file command — copy all files (except info.json) to commands/<name>/
-      const cmdDir = join(dest, name);
-      if (existsSync(cmdDir)) rmSync(cmdDir, { recursive: true });
-      const nonInfo = files.filter(f => f.path !== 'info.json');
-      await downloadToDir(nonInfo, cmdDir);
-    }
+  const files = await listRepoFiles(name, type);
+  if (files.length === 0) throw new Error(`No files found for ${name}`);
+
+  mkdirSync(targetDir, { recursive: true });
+  for (const f of files) {
+    const content = await downloadFile(f.download_url);
+    const targetPath = join(targetDir, f.path);
+    mkdirSync(dirname(targetPath), { recursive: true });
+    writeFileSync(targetPath, content);
   }
 
-  db().prepare('UPDATE skills SET installed_global = 1, installed_version = ? WHERE name = ?').run(version, name);
+  // Update installed state
+  db().prepare('UPDATE skills SET installed_global = 1, installed_version = ? WHERE name = ?')
+    .run(skill.version || '', name);
 }
 
 export async function installProject(name: string, projectPath: string): Promise<void> {
-  console.log(`[skills] Installing "${name}" to ${projectPath.split('/').pop()}`);
-  const row = db().prepare('SELECT type, version FROM skills WHERE name = ?').get(name) as any;
-  if (!row) throw new Error(`Not found: ${name}`);
-  const type: ItemType = row.type || 'skill';
-  const version = row.version || '';
+  const skill = db().prepare('SELECT * FROM skills WHERE name = ?').get(name) as any;
+  if (!skill) throw new Error(`Skill "${name}" not found`);
 
-  const files = await listRepoFiles(name, type);
+  const type: ItemType = skill.type || 'skill';
+  const subdir = type === 'skill' ? 'skills' : 'commands';
+  const targetDir = join(projectPath, '.claude', subdir, name);
 
-  if (type === 'skill') {
-    const dest = join(projectPath, '.claude', 'skills', name);
-    if (existsSync(dest)) rmSync(dest, { recursive: true });
-    await downloadToDir(files, dest);
-  } else {
-    const cmdDir = join(projectPath, '.claude', 'commands');
-    if (!existsSync(cmdDir)) mkdirSync(cmdDir, { recursive: true });
-    const mdFiles = files.filter(f => f.path.endsWith('.md') && f.path !== 'info.json');
-    if (mdFiles.length === 1 && files.filter(f => f.path !== 'info.json').length === 1) {
-      const res = await fetch(mdFiles[0].download_url);
-      if (res.ok) writeFileSync(join(cmdDir, `${name}.md`), await res.text(), 'utf-8');
-    } else {
-      const subDir = join(cmdDir, name);
-      if (existsSync(subDir)) rmSync(subDir, { recursive: true });
-      const nonInfo = files.filter(f => f.path !== 'info.json');
-      await downloadToDir(nonInfo, subDir);
-    }
+  const files = await listRepoFiles(name, type);
+  if (files.length === 0) throw new Error(`No files found for ${name}`);
+
+  mkdirSync(targetDir, { recursive: true });
+  for (const f of files) {
+    const content = await downloadFile(f.download_url);
+    const targetPath = join(targetDir, f.path);
+    mkdirSync(dirname(targetPath), { recursive: true });
+    writeFileSync(targetPath, content);
   }
 
-  // Update installed_projects + version
-  const current = db().prepare('SELECT installed_projects FROM skills WHERE name = ?').get(name) as any;
-  const projects: string[] = JSON.parse(current?.installed_projects || '[]');
-  if (!projects.includes(projectPath)) {
-    projects.push(projectPath);
-  }
+  // Update installed state
+  const existing = JSON.parse(skill.installed_projects || '[]');
+  if (!existing.includes(projectPath)) existing.push(projectPath);
   db().prepare('UPDATE skills SET installed_projects = ?, installed_version = ? WHERE name = ?')
-    .run(JSON.stringify(projects), version, name);
+    .run(JSON.stringify(existing), skill.version || '', name);
 }
 
 // ─── Uninstall ───────────────────────────────────────────────
 
 export function uninstallGlobal(name: string): void {
-  console.log(`[skills] Uninstalling "${name}" from global`);
-  // Remove from all possible locations
-  try { rmSync(join(GLOBAL_SKILLS_DIR, name), { recursive: true }); } catch {}
-  try { unlinkSync(join(GLOBAL_COMMANDS_DIR, `${name}.md`)); } catch {}
-  try { rmSync(join(GLOBAL_COMMANDS_DIR, name), { recursive: true }); } catch {}
-
-  db().prepare('UPDATE skills SET installed_global = 0, installed_version = ? WHERE name = ?')
-    .run('', name);
+  const skill = db().prepare('SELECT * FROM skills WHERE name = ?').get(name) as any;
+  if (!skill) return;
+
+  const type: ItemType = skill.type || 'skill';
+  const claudeHome = getClaudeHome();
+  const subdir = type === 'skill' ? 'skills' : 'commands';
+  const targetDir = join(claudeHome, subdir, name);
+
+  if (existsSync(targetDir)) rmSync(targetDir, { recursive: true, force: true });
+
+  db().prepare('UPDATE skills SET installed_global = 0 WHERE name = ?').run(name);
+  // Clear installed_version if no project installs remain
+  const remaining = JSON.parse(skill.installed_projects || '[]');
+  if (remaining.length === 0) {
+    db().prepare('UPDATE skills SET installed_version = ? WHERE name = ?').run('', name);
+  }
 }
 
 export function uninstallProject(name: string, projectPath: string): void {
-  console.log(`[skills] Uninstalling "${name}" from ${projectPath.split('/').pop()}`);
-  // Remove from all possible locations
-  try { rmSync(join(projectPath, '.claude', 'skills', name), { recursive: true }); } catch {}
-  try { unlinkSync(join(projectPath, '.claude', 'commands', `${name}.md`)); } catch {}
-  try { rmSync(join(projectPath, '.claude', 'commands', name), { recursive: true }); } catch {}
-
-  const current = db().prepare('SELECT installed_projects FROM skills WHERE name = ?').get(name) as any;
-  const projects: string[] = JSON.parse(current?.installed_projects || '[]');
-  const updated = projects.filter(p => p !== projectPath);
-  db().prepare('UPDATE skills SET installed_projects = ? WHERE name = ?').run(JSON.stringify(updated), name);
-  // Clear installed_version if no longer installed anywhere
-  if (updated.length === 0) {
-    const row2 = db().prepare('SELECT installed_global FROM skills WHERE name = ?').get(name) as any;
-    if (!row2?.installed_global) {
-      db().prepare('UPDATE skills SET installed_version = ? WHERE name = ?').run('', name);
-    }
+  const skill = db().prepare('SELECT * FROM skills WHERE name = ?').get(name) as any;
+  if (!skill) return;
+
+  const type: ItemType = skill.type || 'skill';
+  const subdir = type === 'skill' ? 'skills' : 'commands';
+  const targetDir = join(projectPath, '.claude', subdir, name);
+
+  if (existsSync(targetDir)) rmSync(targetDir, { recursive: true, force: true });
+
+  const existing = JSON.parse(skill.installed_projects || '[]').filter((p: string) => p !== projectPath);
+  db().prepare('UPDATE skills SET installed_projects = ? WHERE name = ?')
+    .run(JSON.stringify(existing), name);
+  // Clear installed_version if nothing remains
+  if (!skill.installed_global && existing.length === 0) {
+    db().prepare('UPDATE skills SET installed_version = ? WHERE name = ?').run('', name);
   }
 }
 
-// ─── Scan installed state from filesystem ────────────────────
+// ─── Refresh install state from filesystem ───────────────────
 
 export function refreshInstallState(projectPaths: string[]): void {
-  const items = db().prepare('SELECT name, type FROM skills').all() as { name: string; type: string }[];
+  const claudeHome = getClaudeHome();
+  const rows = db().prepare('SELECT name, type FROM skills').all() as any[];
 
-  for (const { name, type } of items) {
-    let globalInstalled = false;
-    let installedVersion = '';
+  for (const row of rows) {
+    const type: ItemType = row.type || 'skill';
+    const subdir = type === 'skill' ? 'skills' : 'commands';
 
-    // Check BOTH locations — skill dir and command file/dir
-    const skillDir = join(GLOBAL_SKILLS_DIR, name);
-    const cmdFile = join(GLOBAL_COMMANDS_DIR, `${name}.md`);
-    const cmdDir = join(GLOBAL_COMMANDS_DIR, name);
-
-    if (existsSync(skillDir)) {
-      globalInstalled = true;
-      installedVersion = getInstalledVersion(name, 'skill');
-    } else if (existsSync(cmdFile)) {
-      globalInstalled = true;
-    } else if (existsSync(cmdDir)) {
-      globalInstalled = true;
-    }
+    // Check global
+    const globalDir = join(claudeHome, subdir, row.name);
+    const globalInstalled = existsSync(globalDir);
 
+    // Check projects
     const installedIn: string[] = [];
     for (const pp of projectPaths) {
-      // Check all possible install locations for this project
-      const projSkillDir = join(pp, '.claude', 'skills', name);
-      const projCmdFile = join(pp, '.claude', 'commands', `${name}.md`);
-      const projCmdDir = join(pp, '.claude', 'commands', name);
-      if (existsSync(projSkillDir) || existsSync(projCmdFile) || existsSync(projCmdDir)) {
-        installedIn.push(pp);
+      const projDir = join(pp, '.claude', subdir, row.name);
+      if (existsSync(projDir)) installedIn.push(pp);
+    }
+
+    // Read installed version from info.json if available
+    let installedVersion = '';
+    const checkDirs = globalInstalled ? [globalDir] : installedIn.length > 0 ? [join(installedIn[0], '.claude', subdir, row.name)] : [];
+    for (const d of checkDirs) {
+      const infoPath = join(d, 'info.json');
+      if (existsSync(infoPath)) {
+        try {
+          const info = JSON.parse(readFileSync(infoPath, 'utf-8'));
+          installedVersion = info.version || '';
+        } catch {}
+        break;
       }
     }
 
-    db().prepare('UPDATE skills SET installed_global = ?, installed_projects = ?, installed_version = CASE WHEN ? != \'\' THEN ? ELSE installed_version END WHERE name = ?')
-      .run(globalInstalled ? 1 : 0, JSON.stringify(installedIn), installedVersion, installedVersion, name);
+    db().prepare('UPDATE skills SET installed_global = ?, installed_projects = ?, installed_version = ? WHERE name = ?')
+      .run(globalInstalled ? 1 : 0, JSON.stringify(installedIn), installedVersion, row.name);
   }
 }
 
 // ─── Check local modifications ───────────────────────────────
 
-/** Compare local installed files against remote. Returns true if any file was locally modified. */
 export async function checkLocalModified(name: string): Promise<boolean> {
-  const row = db().prepare('SELECT type FROM skills WHERE name = ?').get(name) as any;
-  if (!row) return false;
-  const type: ItemType = row.type || 'command';
+  const skill = db().prepare('SELECT * FROM skills WHERE name = ?').get(name) as any;
+  if (!skill) return false;
 
-  // Get remote file list
-  const remoteFiles = await listRepoFiles(name, type);
+  const type: ItemType = skill.type || 'skill';
+  const claudeHome = getClaudeHome();
+  const subdir = type === 'skill' ? 'skills' : 'commands';
+  const localDir = join(claudeHome, subdir, name);
 
-  // Compare each file
-  for (const rf of remoteFiles) {
-    if (rf.path === 'info.json') continue; // skip metadata
+  if (!existsSync(localDir)) return false;
 
-    let localPath: string;
-    if (type === 'skill') {
-      localPath = join(GLOBAL_SKILLS_DIR, name, rf.path);
-    } else {
-      // Single file command
-      const cmdFile = join(GLOBAL_COMMANDS_DIR, `${name}.md`);
-      const cmdDir = join(GLOBAL_COMMANDS_DIR, name);
-      if (existsSync(cmdDir)) {
-        localPath = join(cmdDir, rf.path);
-      } else {
-        localPath = cmdFile;
-      }
+  // Compare with remote files
+  try {
+    const remoteFiles = await listRepoFiles(name, type);
+    for (const rf of remoteFiles) {
+      const localPath = join(localDir, rf.path);
+      if (!existsSync(localPath)) return true;
+      const localContent = readFileSync(localPath, 'utf-8');
+      const remoteContent = await downloadFile(rf.download_url);
+      if (localContent !== remoteContent) return true;
     }
-
-    if (!existsSync(localPath)) continue;
-    const localContent = readFileSync(localPath, 'utf-8');
-
-    // Fetch remote content
-    try {
-      const res = await fetch(rf.download_url);
-      if (!res.ok) continue;
-      const remoteContent = await res.text();
-      const localHash = createHash('md5').update(localContent).digest('hex');
-      const remoteHash = createHash('md5').update(remoteContent).digest('hex');
-      if (localHash !== remoteHash) return true;
-    } catch { continue; }
+  } catch {
+    return false;
   }
 
   return false;
 }
 
-// ─── Local-to-local install (copy between projects/global) ───
-
-/** Recursively copy a directory */
-function copyDir(src: string, dest: string): void {
-  if (!existsSync(dest)) mkdirSync(dest, { recursive: true });
-  for (const entry of readdirSync(src, { withFileTypes: true })) {
-    const srcPath = join(src, entry.name);
-    const destPath = join(dest, entry.name);
-    if (entry.isDirectory()) {
-      copyDir(srcPath, destPath);
-    } else {
-      writeFileSync(destPath, readFileSync(srcPath));
-    }
-  }
-}
-
-/** Resolve the source path for a local skill/command */
-function resolveLocalSource(name: string, type: string, sourceProject?: string): string | null {
-  const base = sourceProject ? join(sourceProject, '.claude') : join(getClaudeDir());
-  if (type === 'skill') {
-    const dir = join(base, 'skills', name);
-    if (existsSync(dir)) return dir;
-  } else {
-    const file = join(base, 'commands', `${name}.md`);
-    if (existsSync(file)) return file;
-    const dir = join(base, 'commands', name);
-    if (existsSync(dir)) return dir;
-  }
-  return null;
-}
+// ─── Purge deleted skill ─────────────────────────────────────
 
-/** Install a local skill/command to a target (global or project path). Force=overwrite existing. */
-export function installLocal(name: string, type: string, sourceProject: string | undefined, target: string, force?: boolean): { ok: boolean; error?: string } {
-  const src = resolveLocalSource(name, type, sourceProject);
-  if (!src) return { ok: false, error: 'Source not found' };
-
-  const isGlobal = target === 'global';
-  const isFile = !existsSync(src) ? false : require('node:fs').statSync(src).isFile();
-
-  if (type === 'skill') {
-    const dest = isGlobal
-      ? join(GLOBAL_SKILLS_DIR, name)
-      : join(target, '.claude', 'skills', name);
-    if (existsSync(dest) && !force) return { ok: false, error: 'Already installed. Use force to overwrite.' };
-    if (existsSync(dest)) rmSync(dest, { recursive: true });
-    copyDir(src, dest);
-  } else {
-    const destBase = isGlobal ? GLOBAL_COMMANDS_DIR : join(target, '.claude', 'commands');
-    if (!existsSync(destBase)) mkdirSync(destBase, { recursive: true });
-    if (isFile) {
-      const destFile = join(destBase, `${name}.md`);
-      if (existsSync(destFile) && !force) return { ok: false, error: 'Already installed. Use force to overwrite.' };
-      writeFileSync(destFile, readFileSync(src));
-    } else {
-      const dest = join(destBase, name);
-      if (existsSync(dest) && !force) return { ok: false, error: 'Already installed. Use force to overwrite.' };
-      if (existsSync(dest)) rmSync(dest, { recursive: true });
-      copyDir(src, dest);
-    }
-  }
-
-  return { ok: true };
-}
-
-/** Remove all local files for a skill deleted from the remote registry, then drop its DB record. */
 export function purgeDeletedSkill(name: string): void {
-  const row = db().prepare('SELECT type, installed_projects FROM skills WHERE name = ?').get(name) as any;
-  if (!row) return;
-  const type: string = row.type || 'skill';
-  const projects: string[] = JSON.parse(row.installed_projects || '[]');
+  const skill = db().prepare('SELECT * FROM skills WHERE name = ?').get(name) as any;
+  if (!skill) return;
 
-  // Remove global files
-  try { rmSync(join(GLOBAL_SKILLS_DIR, name), { recursive: true }); } catch {}
-  try { unlinkSync(join(GLOBAL_COMMANDS_DIR, `${name}.md`)); } catch {}
-  try { rmSync(join(GLOBAL_COMMANDS_DIR, name), { recursive: true }); } catch {}
+  const type: ItemType = skill.type || 'skill';
+  const claudeHome = getClaudeHome();
+  const subdir = type === 'skill' ? 'skills' : 'commands';
 
-  // Remove project-local files
+  // Remove global
+  const globalDir = join(claudeHome, subdir, name);
+  if (existsSync(globalDir)) rmSync(globalDir, { recursive: true, force: true });
+
+  // Remove from projects
+  const projects = JSON.parse(skill.installed_projects || '[]');
   for (const pp of projects) {
-    try { rmSync(join(pp, '.claude', 'skills', name), { recursive: true }); } catch {}
-    try { unlinkSync(join(pp, '.claude', 'commands', `${name}.md`)); } catch {}
-    try { rmSync(join(pp, '.claude', 'commands', name), { recursive: true }); } catch {}
+    const projDir = join(pp, '.claude', subdir, name);
+    if (existsSync(projDir)) rmSync(projDir, { recursive: true, force: true });
   }
 
-  // Remove DB record entirely
   db().prepare('DELETE FROM skills WHERE name = ?').run(name);
 }
-
-/** Delete a local skill/command from a specific project or global */
-export function deleteLocal(name: string, type: string, projectPath?: string): boolean {
-  const base = projectPath ? join(projectPath, '.claude') : getClaudeDir();
-  if (type === 'skill') {
-    const dir = join(base, 'skills', name);
-    try { rmSync(dir, { recursive: true }); return true; } catch { return false; }
-  } else {
-    // Try file first, then directory
-    const file = join(base, 'commands', `${name}.md`);
-    const dir = join(base, 'commands', name);
-    let deleted = false;
-    try { unlinkSync(file); deleted = true; } catch {}
-    try { rmSync(dir, { recursive: true }); deleted = true; } catch {}
-    return deleted;
-  }
-}