Merge pull request Dimillian#6 from lRoMYl/feature/simple-cache

Minor fetch performance update with URLCache or NSCache

Author: Dimillian

Sources/CodexSkillManager/Skills/Remote/RemoteSkillClient.swift

@@ -9,8 +9,20 @@ struct RemoteSkillClient {
 }
 
 extension RemoteSkillClient {
+    // Static URLSession configured with URLCache (10MB memory, 50MB disk)
+    // Shared across all client instances for efficiency
+    private static let session: URLSession = {
+        let urlCache = URLCache(
+            memoryCapacity: 10 * 1024 * 1024,
+            diskCapacity: 50 * 1024 * 1024
+        )
+        let config = URLSessionConfiguration.default
+        config.urlCache = urlCache
+        return URLSession(configuration: config)
+    }()
+
     static func live(baseURL: URL = URL(string: "https://clawdhub.com")!) -> RemoteSkillClient {
-        let session = URLSession.shared
+        let session = Self.session
 
         return RemoteSkillClient(
             fetchLatest: { limit in

Sources/CodexSkillManager/Skills/Remote/RemoteSkillDetailCache.swift

@@ -0,0 +1,39 @@
+import Foundation
+
+/// Cached detail data for a remote skill
+struct CachedSkillDetail {
+    let markdown: String
+    let owner: RemoteSkillOwner?
+}
+
+/// Memory cache for remote skill details using NSCache
+/// Provides automatic memory pressure eviction
+final class RemoteSkillDetailCache: @unchecked Sendable {
+    static let shared = RemoteSkillDetailCache()
+
+    private let cache = NSCache<NSString, CacheEntry>()
+
+    /// Wrapper class since NSCache requires reference types
+    private final class CacheEntry {
+        let detail: CachedSkillDetail
+        init(_ detail: CachedSkillDetail) { self.detail = detail }
+    }
+
+    private init() {
+        cache.countLimit = 50
+    }
+
+    func get(slug: String, version: String?) -> CachedSkillDetail? {
+        let key = cacheKey(slug: slug, version: version)
+        return cache.object(forKey: key)?.detail
+    }
+
+    func set(_ detail: CachedSkillDetail, slug: String, version: String?) {
+        let key = cacheKey(slug: slug, version: version)
+        cache.setObject(CacheEntry(detail), forKey: key)
+    }
+
+    private func cacheKey(slug: String, version: String?) -> NSString {
+        "\(slug):\(version ?? "latest")" as NSString
+    }
+}

Sources/CodexSkillManager/Skills/Remote/RemoteSkillDetailView.swift

@@ -12,7 +12,7 @@ struct RemoteSkillDetailView: View {
                     loadingView(for: skill)
                 case .failed(let message):
                     errorView(for: skill, message: message)
-                case .loaded:
+                case .loaded, .cachedRefreshing:
                     markdownView(for: skill)
                 }
             }

Sources/CodexSkillManager/Skills/Remote/RemoteSkillStore.swift

@@ -14,6 +14,7 @@ import Observation
         case idle
         case loading
         case loaded
+        case cachedRefreshing
         case failed(String)
     }
 
@@ -28,6 +29,7 @@ import Observation
 
     private let apiClient: RemoteSkillClient
     private let fileWorker = SkillFileWorker()
+    private let detailCache = RemoteSkillDetailCache.shared
     private var activeSearchToken = 0
     private var activeSearchQuery = ""
 
@@ -86,18 +88,45 @@ import Observation
             return
         }
 
-        detailState = .loading
-        detailOwner = nil
+        // Check NSCache first (application-level cache)
+        if let cached = detailCache.get(slug: skill.slug, version: skill.latestVersion) {
+            detailMarkdown = cached.markdown
+            detailOwner = cached.owner
+            detailState = .cachedRefreshing
+        } else {
+            detailState = .loading
+            detailMarkdown = ""
+            detailOwner = nil
+        }
 
+        // Fetch from network (URLCache may provide HTTP-level caching)
         do {
-            detailOwner = try await apiClient.fetchDetail(skill.slug)
+            let owner = try await apiClient.fetchDetail(skill.slug)
             let zipURL = try await apiClient.download(skill.slug, skill.latestVersion)
-            let markdown = try await fileWorker.loadRawMarkdown(from: zipURL)
-            detailMarkdown = stripFrontmatter(from: markdown)
+            let markdown = stripFrontmatter(from: try await fileWorker.loadRawMarkdown(from: zipURL))
+
+            guard skill.id == selectedSkillID else { return }
+
+            // Update NSCache with fresh data
+            detailCache.set(
+                CachedSkillDetail(markdown: markdown, owner: owner),
+                slug: skill.slug,
+                version: skill.latestVersion
+            )
+
+            detailOwner = owner
+            detailMarkdown = markdown
             detailState = .loaded
         } catch {
-            detailState = .failed(error.localizedDescription)
-            detailMarkdown = ""
+            guard skill.id == selectedSkillID else { return }
+
+            // If we had cached content, silently keep showing it
+            if detailState == .cachedRefreshing {
+                detailState = .loaded
+            } else {
+                detailState = .failed(error.localizedDescription)
+                detailMarkdown = ""
+            }
         }
     }
 

Sources/CodexSkillManager/Skills/Sidebar/SkillListView.swift

@@ -2,6 +2,7 @@ import SwiftUI
 
 struct SkillListView: View {
     @Environment(SkillStore.self) private var store
+    @Environment(RemoteSkillStore.self) private var remoteStore
 
     let localSkills: [Skill]
     let remoteLatestSkills: [RemoteSkill]
@@ -55,12 +56,18 @@ struct SkillListView: View {
         .toolbar {
             ToolbarItem(placement: .primaryAction) {
                 Button {
-                    Task { await store.loadSkills() }
+                    Task {
+                        switch source {
+                        case .local:
+                            await store.loadSkills()
+                        case .clawdhub:
+                            await remoteStore.loadLatest()
+                        }
+                    }
                 } label: {
                     Label("Reload", systemImage: "arrow.clockwise")
                 }
                 .labelStyle(.iconOnly)
-                .disabled(source != .local)
             }
         }
     }

Sources/CodexSkillManager/Skills/SkillSplitView.swift

@@ -338,8 +338,6 @@ private struct SkillSplitLifecycleModifier: ViewModifier {
                     Task { await store.loadSelectedSkill() }
                     searchTask?.cancel()
                     searchTask = nil
-                } else {
-                    Task { await remoteStore.loadLatest() }
                 }
             }
             .onChange(of: searchText) { _, newValue in