Stash

.gitignore

@@ -74,3 +74,5 @@ fastlane/metadata/trade_representative_contact_information
 
 vendor/
 .bundle/
+
+Config.xcconfig

.swift-version

@@ -1 +1 @@
-5.8
+5.9

App/Entity/Entry.swift

@@ -2,6 +2,7 @@ import CoreData
 import CoreSpotlight
 import Foundation
 import SharedLib
+
 // import MobileCoreServices
 import WallabagKit
 

App/Features/AI/ChatAssistant.swift

@@ -0,0 +1,56 @@
+import Foundation
+import HTTPTypes
+import OpenAPIRuntime
+import OpenAPIURLSession
+
+protocol ChatAssistantProtocol {
+    func generateSynthesis(content: String) async throws -> String
+    func generateTags(content: String) async throws -> [String]
+}
+
+struct ChatAssistant: ChatAssistantProtocol {
+    var client: Client {
+        get throws {
+            try Client(
+                serverURL: Servers.server1(),
+                transport: URLSessionTransport(),
+                middlewares: [AuthenticationMiddleware()]
+            )
+        }
+    }
+
+    var locale = Locale.current.identifier
+
+    func generateSynthesis(content: String) async throws -> String {
+        let response = try await client.wallabagSynthesis(body: .json(.init(body: content, language: locale)))
+
+        return try response.ok.body.json.content ?? ""
+    }
+
+    func generateTags(content: String) async throws -> [String] {
+        let response = try await client.wallabagTags(body: .json(.init(body: content, language: locale)))
+
+        return try response.ok.body.json.tags ?? []
+    }
+}
+
+private struct AuthenticationMiddleware: ClientMiddleware {
+    @BundleKey("GPTBACK_KEY")
+    private var gptBackKey
+
+    func intercept(
+        _ request: HTTPTypes.HTTPRequest,
+        body: OpenAPIRuntime.HTTPBody?,
+        baseURL: URL,
+        operationID _: String,
+        next: @Sendable (HTTPTypes.HTTPRequest, OpenAPIRuntime.HTTPBody?, URL) async throws -> (
+            HTTPTypes.HTTPResponse,
+            OpenAPIRuntime.HTTPBody?
+        )
+    ) async throws -> (HTTPTypes.HTTPResponse, OpenAPIRuntime.HTTPBody?) {
+        var request = request
+        request.headerFields[.authorization] = "Bearer \(gptBackKey)"
+
+        return try await next(request, body, baseURL)
+    }
+}

App/Features/AI/SynthesisEntryView.swift

@@ -0,0 +1,57 @@
+//
+//  SynthesisEntryView.swift
+//  wallabag
+//
+//  Created by maxime marinel on 11/12/2023.
+//
+
+import Factory
+import SwiftUI
+
+final class SynthesisEntryViewModel: ObservableObject {
+    @Injected(\.chatAssistant) private var chatAssistant
+    @Published var synthesis = ""
+    @Published var isLoading = false
+
+    @MainActor
+    func generateSynthesis(from entry: Entry) async throws {
+        defer {
+            isLoading = false
+        }
+        isLoading = true
+
+        guard let content = entry.content?.withoutHTML else { return }
+
+        synthesis = try await chatAssistant.generateSynthesis(content: content)
+    }
+}
+
+struct SynthesisEntryView: View {
+    @StateObject private var viewModel = SynthesisEntryViewModel()
+    let entry: Entry
+
+    var body: some View {
+        ScrollView {
+            if viewModel.isLoading {
+                Text("Your assistant is working")
+                ProgressView()
+            } else {
+                Text(viewModel.synthesis)
+                    .padding()
+                    .fontDesign(.serif)
+            }
+        }
+        .navigationTitle("Synthesis")
+        .task {
+            do {
+                try await viewModel.generateSynthesis(from: entry)
+            } catch {
+                print(error)
+            }
+        }
+    }
+}
+
+// #Preview {
+//    SynthesisEntryView(entry: .)
+// }

App/Features/AI/TagSuggestionView.swift

@@ -0,0 +1,78 @@
+import Factory
+import SwiftUI
+
+final class TagSuggestionViewModel: ObservableObject {
+    @Injected(\.chatAssistant) private var chatAssistant
+    @Published var suggestions: [String] = []
+    @Published var isLoading = false
+
+    @MainActor
+    func generateSynthesis(from entry: Entry) async throws {
+        defer {
+            isLoading = false
+        }
+        isLoading = true
+
+        guard let content = entry.content?.withoutHTML else { return }
+
+        suggestions = try await chatAssistant.generateTags(content: content)
+    }
+}
+
+struct TagSuggestionView: View {
+    @StateObject private var viewModel = TagSuggestionViewModel()
+    @State private var selection = Set<String>()
+
+    let entry: Entry
+
+    var body: some View {
+        VStack {
+            if viewModel.isLoading {
+                Text("Your assistant is working")
+                ProgressView()
+            } else {
+                List {
+                    ForEach(viewModel.suggestions, id: \.self) { suggestion in
+                        Button(action: {
+                            if selection.contains(suggestion) {
+                                selection.remove(suggestion)
+                            } else {
+                                selection.insert(suggestion)
+                            }
+                        }, label: {
+                            HStack {
+                                Text(suggestion)
+                                    .padding()
+                                    .fontDesign(.serif)
+                                Spacer()
+                                if selection.contains(suggestion) {
+                                    Image(systemName: "checkmark.circle.fill")
+                                } else {
+                                    Image(systemName: "circle")
+                                }
+                            }
+                        })
+                    }
+                }
+                .listStyle(.plain)
+                if !selection.isEmpty {
+                    Button(action: {}, label: {
+                        Text("Add \(selection.count.formatted()) tags")
+                    })
+                }
+            }
+        }
+        .navigationTitle("Tag suggestion")
+        .task {
+            do {
+                try await viewModel.generateSynthesis(from: entry)
+            } catch {
+                print(error)
+            }
+        }
+    }
+}
+
+// #Preview {
+//    SynthesisEntryView(entry: .)
+// }

App/Features/Entry/EntriesView.swift

@@ -46,6 +46,10 @@ struct EntriesView: View {
                         Label("Don", systemImage: "heart")
                     })
                     Divider()
+                    NavigationLink(value: RoutePath.wallabagPlus) {
+                        Label("wallabag Plus", systemImage: "hands.and.sparkles")
+                    }
+                    Divider()
                     Button(action: {
                         router.path.append(RoutePath.setting)
                     }, label: {

App/Features/Entry/EntryView.swift

@@ -52,6 +52,20 @@ struct EntryView: View {
                 FontSizeSelectorView()
                     .buttonStyle(.plain)
             }
+            ToolbarItem(placement: toolbarPlacement) {
+                Menu(content: {
+                    NavigationLink(value: RoutePath.synthesis(entry), label: {
+                        Text("Synthesis")
+                    })
+                    NavigationLink(value: RoutePath.tags(entry), label: {
+                        Text("Suggest tag")
+                    })
+                }, label: {
+                    Label("Help assistant", systemImage: "hands.and.sparkles")
+                        .foregroundColor(.primary)
+                        .labelStyle(.iconOnly)
+                })
+            }
         }
         .actionSheet(isPresented: $showDeleteConfirm) {
             ActionSheet(

App/Features/Entry/Picture/ImageCache.swift

@@ -60,8 +60,8 @@ import Foundation
             let url = FileManager.default.urls(for: .cachesDirectory, in: .userDomainMask)[0]
             do {
                 let files = try FileManager.default.contentsOfDirectory(atPath: url.path)
-                try files.forEach {
-                    try FileManager.default.removeItem(atPath: url.appendingPathComponent($0).path)
+                for file in files {
+                    try FileManager.default.removeItem(atPath: url.appendingPathComponent(file).path)
                 }
             } catch {
                 print("Error in cache purge")

App/Features/Router/Route.swift

@@ -5,7 +5,10 @@ enum RoutePath: Hashable {
     case registration
     case addEntry
     case entry(Entry)
+    case synthesis(Entry)
+    case tags(Entry)
     case tips
     case about
     case setting
+    case wallabagPlus
 }

App/Features/Router/RouteSwiftUIExtension.swift

@@ -16,14 +16,22 @@ extension View {
                 AddEntryView()
             case let .entry(entry):
                 EntryView(entry: entry)
+            case let .synthesis(entry):
+                SynthesisEntryView(entry: entry)
+                    .wallabagPlusProtected()
+            case let .tags(entry):
+                TagSuggestionView(entry: entry)
+                    .wallabagPlusProtected()
             case .about:
                 AboutView()
             case .tips:
                 TipView()
             case .setting:
                 SettingView()
-            default:
-                Text("test")
+            case .wallabagPlus:
+                WallabagPlusView()
+            case .registration:
+                RegistrationView()
             }
         }
     }

App/Features/Sync/AppSync.swift

@@ -58,12 +58,12 @@ extension AppSync {
     }
 
     private func handleEntries(_ wallabagEntries: [WallabagEntry]) {
-        wallabagEntries.forEach { wallabagEntry in
-            self.entriesSynced.append(wallabagEntry.id)
-            if let entry = try? self.backgroundContext.fetch(Entry.fetchOneById(wallabagEntry.id)).first {
-                self.update(entry, with: wallabagEntry)
+        for wallabagEntry in wallabagEntries {
+            entriesSynced.append(wallabagEntry.id)
+            if let entry = try? backgroundContext.fetch(Entry.fetchOneById(wallabagEntry.id)).first {
+                update(entry, with: wallabagEntry)
             } else {
-                self.insert(wallabagEntry)
+                insert(wallabagEntry)
             }
         }
     }
@@ -122,15 +122,15 @@ extension AppSync {
 
     private func synchronizeTags() async {
         do {
-            try await fetchTags().forEach { wallabagTag in
-                if let tag = try? self.backgroundContext.fetch(Tag.fetchOneById(wallabagTag.id)).first {
-                    self.tags[tag.id] = tag
+            try await for wallabagTag in fetchTags() {
+                if let tag = try? backgroundContext.fetch(Tag.fetchOneById(wallabagTag.id)).first {
+                    tags[tag.id] = tag
                 } else {
-                    let tag = Tag(context: self.backgroundContext)
+                    let tag = Tag(context: backgroundContext)
                     tag.id = wallabagTag.id
                     tag.label = wallabagTag.label
                     tag.slug = wallabagTag.slug
-                    self.tags[wallabagTag.id] = tag
+                    tags[wallabagTag.id] = tag
                 }
             }
         } catch _ {}

App/Features/WallabagPlus/WallabagPlusProtectedModifier.swift

@@ -0,0 +1,25 @@
+import SwiftUI
+
+struct WallabagPlusProtectedModifier: ViewModifier {
+    @EnvironmentObject private var wallabagPlusStore: WallabagPlusStore
+
+    func body(content: Content) -> some View {
+        VStack {
+            if wallabagPlusStore.proUnlocked {
+                content
+            } else {
+                Image("logo")
+                    .resizable()
+                    .scaledToFit()
+                Text("Sorry, this feature require you subscribe to wallabag Plus")
+                    .fontDesign(.rounded)
+            }
+        }
+    }
+}
+
+extension View {
+    func wallabagPlusProtected() -> some View {
+        modifier(WallabagPlusProtectedModifier())
+    }
+}