Create WordPressIntelligence module and enable for other locales

Author: kean

Modules/Package.swift

@@ -20,6 +20,7 @@ let package = Package(
         .library(name: "WordPressFlux", targets: ["WordPressFlux"]),
         .library(name: "WordPressShared", targets: ["WordPressShared"]),
         .library(name: "WordPressUI", targets: ["WordPressUI"]),
+        .library(name: "WordPressIntelligence", targets: ["WordPressIntelligence"]),
         .library(name: "WordPressReader", targets: ["WordPressReader"]),
         .library(name: "WordPressCore", targets: ["WordPressCore"]),
         .library(name: "WordPressCoreProtocols", targets: ["WordPressCoreProtocols"]),
@@ -163,6 +164,10 @@ let package = Package(
             // This package should never have dependencies – it exists to expose protocols implemented in WordPressCore
             // to UI code, because `wordpress-rs` doesn't work nicely with previews.
         ]),
+        .target(name: "WordPressIntelligence", dependencies: [
+            "WordPressShared",
+            .product(name: "SwiftSoup", package: "SwiftSoup"),
+        ]),
         .target(name: "WordPressLegacy", dependencies: ["DesignSystem", "WordPressShared"]),
         .target(name: "WordPressSharedObjC", resources: [.process("Resources")], swiftSettings: [.swiftLanguageMode(.v5)]),
         .target(
@@ -251,6 +256,7 @@ let package = Package(
         .testTarget(name: "WordPressSharedObjCTests", dependencies: [.target(name: "WordPressShared"), .target(name: "WordPressTesting")], swiftSettings: [.swiftLanguageMode(.v5)]),
         .testTarget(name: "WordPressUIUnitTests", dependencies: [.target(name: "WordPressUI")], swiftSettings: [.swiftLanguageMode(.v5)]),
         .testTarget(name: "WordPressCoreTests", dependencies: [.target(name: "WordPressCore")]),
+        .testTarget(name: "WordPressIntelligenceTests", dependencies: [.target(name: "WordPressIntelligence")])
     ]
 )
 

Modules/Sources/WordPressIntelligence/IntelligenceService.swift

@@ -0,0 +1,68 @@
+import Foundation
+import FoundationModels
+
+/// Service for AI-powered content generation and analysis features.
+///
+/// This service provides tag suggestions, post summaries, excerpt generation,
+/// and other intelligence features using Foundation Models (iOS 26+).
+public actor IntelligenceService {
+    /// Maximum context size for language model sessions (in tokens).
+    ///
+    /// A single token corresponds to three or four characters in languages like
+    /// English, Spanish, or German, and one token per character in languages like
+    /// Japanese, Chinese, or Korean. In a single session, the sum of all tokens
+    /// in the instructions, all prompts, and all outputs count toward the context window size.
+    ///
+    /// https://developer.apple.com/documentation/foundationmodels/generating-content-and-performing-tasks-with-foundation-models#Consider-context-size-limits-per-session
+    public static let contextSizeLimit = 4096
+
+    /// Checks if intelligence features are supported on the current device.
+    public nonisolated static var isSupported: Bool {
+        guard #available(iOS 26, *) else {
+            return false
+        }
+        switch SystemLanguageModel.default.availability {
+        case .available:
+            return true
+        case .unavailable(let reason):
+            switch reason {
+            case .appleIntelligenceNotEnabled, .modelNotReady:
+                return true
+            case .deviceNotEligible:
+                return false
+            @unknown default:
+                return false
+            }
+        }
+    }
+
+    public init() {}
+
+    // MARK: - Public API
+
+    /// Suggests tags for a WordPress post.
+    @available(iOS 26, *)
+    public func suggestTags(post: String, siteTags: [String] = [], postTags: [String] = []) async throws -> [String] {
+        try await TagSuggestion().generate(post: post, siteTags: siteTags, postTags: postTags)
+    }
+
+    /// Summarizes a support ticket to a short title.
+    @available(iOS 26, *)
+    public func summarizeSupportTicket(content: String) async throws -> String {
+        try await SupportTicketSummary.execute(content: content)
+    }
+
+    /// Extracts relevant text from post content (removes HTML, limits size).
+    public nonisolated func extractRelevantText(from post: String, ratio: CGFloat = 0.6) -> String {
+        Self.extractRelevantText(from: post, ratio: ratio)
+    }
+
+    // MARK: - Shared Utilities
+
+    /// Extracts relevant text from post content, removing HTML and limiting size.
+    public nonisolated static func extractRelevantText(from post: String, ratio: CGFloat = 0.6) -> String {
+        let extract = try? ContentExtractor.extractRelevantText(from: post)
+        let postSizeLimit = Double(IntelligenceService.contextSizeLimit) * ratio
+        return String((extract ?? post).prefix(Int(postSizeLimit)))
+    }
+}

Modules/Sources/WordPressIntelligence/Parameters/ContentLength.swift

@@ -0,0 +1,58 @@
+import Foundation
+import WordPressShared
+
+/// Target length for generated text.
+///
+/// Ranges are calibrated for English and account for cross-language variance.
+/// Sentences are the primary indicator; word counts accommodate language differences.
+///
+/// - **Short**: 1-2 sentences (15-35 words) - Social media, search snippets
+/// - **Medium**: 2-4 sentences (30-90 words) - RSS feeds, blog listings
+/// - **Long**: 5-7 sentences (90-130 words) - Detailed previews, newsletters
+///
+/// Word ranges are intentionally wide (2-2.3x) to handle differences in language
+/// structure (German compounds, Romance wordiness, CJK tokenization).
+public enum ContentLength: Int, CaseIterable, Sendable {
+    case short
+    case medium
+    case long
+
+    public var displayName: String {
+        switch self {
+        case .short:
+            AppLocalizedString("generation.length.short", value: "Short", comment: "Generated content length (needs to be short)")
+        case .medium:
+            AppLocalizedString("generation.length.medium", value: "Medium", comment: "Generated content length (needs to be short)")
+        case .long:
+            AppLocalizedString("generation.length.long", value: "Long", comment: "Generated content length (needs to be short)")
+        }
+    }
+
+    public var trackingName: String {
+        switch self {
+        case .short: "short"
+        case .medium: "medium"
+        case .long: "long"
+        }
+    }
+
+    public var promptModifier: String {
+        "\(sentenceRange.lowerBound)-\(sentenceRange.upperBound) sentences (\(wordRange.lowerBound)-\(wordRange.upperBound) words)"
+    }
+
+    public var sentenceRange: ClosedRange<Int> {
+        switch self {
+        case .short: 1...2
+        case .medium: 2...4
+        case .long: 5...7
+        }
+    }
+
+    public var wordRange: ClosedRange<Int> {
+        switch self {
+        case .short: 15...35
+        case .medium: 40...80
+        case .long: 90...130
+        }
+    }
+}

Modules/Sources/WordPressIntelligence/Parameters/WritingStyle.swift

@@ -0,0 +1,40 @@
+import Foundation
+import WordPressShared
+
+/// Writing style for generated text.
+public enum WritingStyle: String, CaseIterable, Sendable {
+    case engaging
+    case conversational
+    case witty
+    case formal
+    case professional
+
+    public var displayName: String {
+        switch self {
+        case .engaging:
+            AppLocalizedString("generation.style.engaging", value: "Engaging", comment: "AI generation style")
+        case .conversational:
+            AppLocalizedString("generation.style.conversational", value: "Conversational", comment: "AI generation style")
+        case .witty:
+            AppLocalizedString("generation.style.witty", value: "Witty", comment: "AI generation style")
+        case .formal:
+            AppLocalizedString("generation.style.formal", value: "Formal", comment: "AI generation style")
+        case .professional:
+            AppLocalizedString("generation.style.professional", value: "Professional", comment: "AI generation style")
+        }
+    }
+
+    var promptModifier: String {
+        "\(rawValue) (\(promptModifierDetails))"
+    }
+
+    var promptModifierDetails: String {
+        switch self {
+        case .engaging: "engaging and compelling tone"
+        case .witty: "witty, creative, entertaining"
+        case .conversational: "friendly and conversational tone"
+        case .formal: "formal and academic tone"
+        case .professional: "professional and polished tone"
+        }
+    }
+}

Modules/Sources/WordPressIntelligence/UseCases/ExcerptGeneration.swift

@@ -0,0 +1,105 @@
+import Foundation
+import FoundationModels
+
+/// Excerpt generation for WordPress posts.
+///
+/// Generates multiple excerpt variations for blog posts with customizable
+/// length and writing style. Supports session-based usage (for UI with continuity)
+/// and one-shot generation (for tests and background tasks).
+@available(iOS 26, *)
+public struct ExcerptGeneration {
+    public var length: ContentLength
+    public var style: WritingStyle
+    public var options: GenerationOptions
+
+    public init(
+        length: ContentLength,
+        style: WritingStyle,
+        options: GenerationOptions = GenerationOptions(temperature: 0.7)
+    ) {
+        self.length = length
+        self.style = style
+        self.options = options
+    }
+
+    /// Generates excerpts with this configuration.
+    public func generate(for content: String) async throws -> [String] {
+        let content = IntelligenceService.extractRelevantText(from: content)
+        let response = try await makeSession().respond(
+            to: makePrompt(content: content),
+            generating: Result.self,
+            options: options
+        )
+        return response.content.excerpts
+    }
+
+    /// Creates a language model session configured for excerpt generation.
+    public func makeSession() -> LanguageModelSession {
+        LanguageModelSession(
+            model: .init(guardrails: .permissiveContentTransformations),
+            instructions: Self.instructions
+        )
+    }
+
+    /// Instructions for the language model session.
+    public static var instructions: String {
+        """
+        You are helping a WordPress user generate an excerpt for their post or page.
+
+        **Prompt Parameters**
+        - POST_CONTENT: contents of the post (HTML or plain text)
+        - TARGET_LENGTH: MANDATORY sentence count (primary) and word count (secondary) for each excerpt
+        - GENERATION_STYLE: the writing style to follow
+
+        \(PromptHelper.makeLocaleInstructions())
+
+        **CRITICAL Requirements (MUST be followed exactly)**
+        1. ⚠️ LANGUAGE: Generate excerpts in the SAME language as POST_CONTENT. NO translation. NO defaulting to English. Match input language EXACTLY.
+
+        2. ⚠️ LENGTH: Each excerpt MUST match the TARGET_LENGTH specification.
+           - PRIMARY: Match the sentence count (e.g., "1-2 sentences" means write 1 or 2 complete sentences)
+           - SECONDARY: Stay within the word count range (accommodates language differences)
+           - Write complete sentences only. Count sentences after writing.
+           - VERIFY both sentence and word counts before responding.
+
+        3. ⚠️ STYLE: Follow the GENERATION_STYLE exactly (witty, professional, engaging, etc.)
+
+        **Excerpt best practices**
+        - Follow WordPress ecosystem best practices for post excerpts
+        - Include the post's main value proposition
+        - Use active voice (avoid "is", "are", "was", "were" when possible)
+        - End with implicit promise of more information (no ellipsis)
+        - Include strategic keywords naturally
+        - Write independently from the introduction – don't duplicate the opening paragraph
+        - Make excerpts work as standalone copy for search results, social media, and email
+        """
+    }
+
+    /// Creates a prompt for this excerpt configuration.
+    public func makePrompt(content: String) -> String {
+        """
+        Generate EXACTLY 3 different excerpts for the given post.
+
+        TARGET_LENGTH: \(length.promptModifier)
+        CRITICAL: Write \(length.sentenceRange.lowerBound)-\(length.sentenceRange.upperBound) complete sentences. Stay within \(length.wordRange.lowerBound)-\(length.wordRange.upperBound) words.
+
+        GENERATION_STYLE: \(style.promptModifier)
+
+        POST_CONTENT:
+        \(content)
+        """
+    }
+
+    /// Prompt for generating additional excerpt options.
+    public static var loadMorePrompt: String {
+        "Generate 3 additional excerpts following the same TARGET_LENGTH and GENERATION_STYLE requirements"
+    }
+
+    // MARK: - Result Type
+
+    @Generable
+    public struct Result {
+        @Guide(description: "Suggested post excerpts", .count(3))
+        public var excerpts: [String]
+    }
+}

Modules/Sources/WordPressIntelligence/UseCases/PostSummary.swift

@@ -0,0 +1,81 @@
+import Foundation
+import FoundationModels
+
+/// Post summarization for WordPress content.
+///
+/// Generates concise summaries that capture the main points and key information
+/// from WordPress post content in the same language as the source.
+///
+/// Example usage:
+/// ```swift
+/// let summary = PostSummary()
+/// let result = try await summary.generate(content: postContent)
+/// ```
+@available(iOS 26, *)
+public struct PostSummary {
+    public var options: GenerationOptions
+
+    public init(options: GenerationOptions = GenerationOptions(temperature: 0.3)) {
+        self.options = options
+    }
+
+    /// Generate a summary for the given post content.
+    ///
+    /// - Parameter content: The post content to summarize (HTML or plain text)
+    /// - Returns: A concise summary in the same language as the source
+    /// - Throws: If the language model session fails
+    public func generate(content: String) async throws -> String {
+        let session = makeSession()
+        let prompt = makePrompt(content: content)
+        return try await session.respond(to: prompt).content
+    }
+
+    /// Creates a language model session configured for post summarization.
+    ///
+    /// - Returns: Configured session with instructions
+    public func makeSession() -> LanguageModelSession {
+        LanguageModelSession(
+            model: .init(guardrails: .permissiveContentTransformations),
+            instructions: Self.instructions
+        )
+    }
+
+    /// Instructions for the language model on how to generate summaries.
+    public static var instructions: String {
+        """
+        You are helping a WordPress user understand the content of a post.
+        Generate a concise summary that captures the main points and key information.
+        The summary should be clear, informative, and written in a neutral tone.
+
+        \(PromptHelper.makeLocaleInstructions())
+
+        Do not include anything other than the summary in the response.
+        """
+    }
+
+    /// Builds the prompt for summarizing post content.
+    ///
+    /// - Parameter content: The post content to summarize
+    /// - Returns: Formatted prompt string
+    public func makePrompt(content: String) -> String {
+        let extractedContent = IntelligenceService.extractRelevantText(from: content, ratio: 0.8)
+
+        return """
+        Summarize the following post:
+
+        \(extractedContent)
+        """
+    }
+}
+
+@available(iOS 26, *)
+extension IntelligenceService {
+    /// Post summarization for WordPress content.
+    ///
+    /// - Parameter content: The post content to summarize
+    /// - Returns: A concise summary
+    /// - Throws: If summarization fails
+    public func summarize(content: String) async throws -> String {
+        try await PostSummary().generate(content: content)
+    }
+}