Merge branch 'pr-391' into dannys-build

* pr-391:
  fix(ui): hide Apple Intelligence option when unavailable
  fix(build): add fallback stub for Apple Intelligence on older SDKs
  feat: guide apple intelligence output
  feat: add Apple Intelligence post-processing provider

# Conflicts:
#	src-tauri/src/actions.rs

Author: dannysmith

src-tauri/apple_intelligence.swift

@@ -0,0 +1,127 @@
+import Dispatch
+import Foundation
+import FoundationModels
+
+@available(macOS 26.0, *)
+@Generable
+private struct CleanedTranscript: Sendable {
+    let cleanedText: String
+}
+
+// MARK: - Swift implementation for Apple LLM integration
+// This file is compiled via Cargo build script for Apple Silicon targets
+
+private typealias ResponsePointer = UnsafeMutablePointer<AppleLLMResponse>
+
+private func duplicateCString(_ text: String) -> UnsafeMutablePointer<CChar>? {
+    return text.withCString { basePointer in
+        guard let duplicated = strdup(basePointer) else {
+            return nil
+        }
+        return duplicated
+    }
+}
+
+private func truncatedText(_ text: String, limit: Int) -> String {
+    guard limit > 0 else { return text }
+    let words = text.split(
+        maxSplits: .max,
+        omittingEmptySubsequences: true,
+        whereSeparator: { $0.isWhitespace || $0.isNewline }
+    )
+    if words.count <= limit {
+        return text
+    }
+    return words.prefix(limit).joined(separator: " ")
+}
+
+@_cdecl("is_apple_intelligence_available")
+public func isAppleIntelligenceAvailable() -> Int32 {
+    guard #available(macOS 26.0, *) else {
+        return 0
+    }
+
+    let model = SystemLanguageModel.default
+    switch model.availability {
+    case .available:
+        return 1
+    case .unavailable:
+        return 0
+    }
+}
+
+@_cdecl("process_text_with_apple_llm")
+public func processTextWithAppleLLM(
+    _ prompt: UnsafePointer<CChar>,
+    maxTokens: Int32
+) -> UnsafeMutablePointer<AppleLLMResponse> {
+    let swiftPrompt = String(cString: prompt)
+    let responsePtr = ResponsePointer.allocate(capacity: 1)
+    responsePtr.initialize(to: AppleLLMResponse(response: nil, success: 0, error_message: nil))
+
+    guard #available(macOS 26.0, *) else {
+        responsePtr.pointee.error_message = duplicateCString(
+            "Apple Intelligence requires macOS 26 or newer."
+        )
+        return responsePtr
+    }
+
+    let model = SystemLanguageModel.default
+    guard model.availability == .available else {
+        responsePtr.pointee.error_message = duplicateCString(
+            "Apple Intelligence is not currently available on this device."
+        )
+        return responsePtr
+    }
+
+    let tokenLimit = max(0, Int(maxTokens))
+    let semaphore = DispatchSemaphore(value: 0)
+
+    Task.detached(priority: .userInitiated) {
+        defer { semaphore.signal() }
+        do {
+            let session = LanguageModelSession(model: model)
+            var output: String
+
+            do {
+                let structured = try await session.respond(
+                    to: swiftPrompt,
+                    generating: CleanedTranscript.self
+                )
+                output = structured.content.cleanedText
+            } catch {
+                let fallbackGeneration = try await session.respond(to: swiftPrompt)
+                output = fallbackGeneration.content
+            }
+
+            if tokenLimit > 0 {
+                output = truncatedText(output, limit: tokenLimit)
+            }
+            responsePtr.pointee.response = duplicateCString(output)
+            responsePtr.pointee.success = 1
+            responsePtr.pointee.error_message = nil
+        } catch {
+            responsePtr.pointee.response = nil
+            responsePtr.pointee.success = 0
+            responsePtr.pointee.error_message = duplicateCString(error.localizedDescription)
+        }
+    }
+
+    semaphore.wait()
+    return responsePtr
+}
+
+@_cdecl("free_apple_llm_response")
+public func freeAppleLLMResponse(_ response: UnsafeMutablePointer<AppleLLMResponse>?) {
+    guard let response = response else { return }
+
+    if let responseStr = response.pointee.response {
+        free(UnsafeMutablePointer(mutating: responseStr))
+    }
+
+    if let errorStr = response.pointee.error_message {
+        free(UnsafeMutablePointer(mutating: errorStr))
+    }
+
+    response.deallocate()
+}

src-tauri/apple_intelligence_bridge.h

@@ -0,0 +1,29 @@
+#ifndef apple_intelligence_bridge_h
+#define apple_intelligence_bridge_h
+
+// C-compatible function declarations for Swift bridge
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef struct {
+    char* response;
+    int success; // 0 for failure, 1 for success
+    char* error_message; // Only valid when success = 0
+} AppleLLMResponse;
+
+// Check if Apple Intelligence is available on the device
+int is_apple_intelligence_available(void);
+
+// Process text using Apple's on-device LLM
+AppleLLMResponse* process_text_with_apple_llm(const char* prompt, int max_tokens);
+
+// Free memory allocated by the Apple LLM response
+void free_apple_llm_response(AppleLLMResponse* response);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* apple_intelligence_bridge_h */

src-tauri/apple_intelligence_stub.swift

@@ -0,0 +1,44 @@
+import Foundation
+
+// Stub implementation when FoundationModels is not available
+// This file is compiled via Cargo build script when the build environment
+// does not support Apple Intelligence (e.g. older Xcode/SDK).
+
+private typealias ResponsePointer = UnsafeMutablePointer<AppleLLMResponse>
+
+@_cdecl("is_apple_intelligence_available")
+public func isAppleIntelligenceAvailable() -> Int32 {
+    return 0
+}
+
+@_cdecl("process_text_with_apple_llm")
+public func processTextWithAppleLLM(
+    _ prompt: UnsafePointer<CChar>,
+    maxTokens: Int32
+) -> UnsafeMutablePointer<AppleLLMResponse> {
+    let responsePtr = ResponsePointer.allocate(capacity: 1)
+    // Initialize with safe defaults
+    responsePtr.initialize(to: AppleLLMResponse(response: nil, success: 0, error_message: nil))
+    
+    let msg = "Apple Intelligence is not available in this build (SDK requirement not met)."
+    
+    // Duplicate the string for the C caller to own
+    responsePtr.pointee.error_message = strdup(msg)
+    
+    return responsePtr
+}
+
+@_cdecl("free_apple_llm_response")
+public func freeAppleLLMResponse(_ response: UnsafeMutablePointer<AppleLLMResponse>?) {
+    guard let response = response else { return }
+    
+    if let responseStr = response.pointee.response {
+        free(UnsafeMutablePointer(mutating: responseStr))
+    }
+    
+    if let errorStr = response.pointee.error_message {
+        free(UnsafeMutablePointer(mutating: errorStr))
+    }
+    
+    response.deallocate()
+}

src-tauri/build.rs

@@ -1,3 +1,128 @@
 fn main() {
+    #[cfg(all(target_os = "macos", target_arch = "aarch64"))]
+    build_apple_intelligence_bridge();
+
     tauri_build::build()
 }
+
+#[cfg(all(target_os = "macos", target_arch = "aarch64"))]
+fn build_apple_intelligence_bridge() {
+    use std::env;
+    use std::path::{Path, PathBuf};
+    use std::process::Command;
+
+    const REAL_SWIFT_FILE: &str = "apple_intelligence.swift";
+    const STUB_SWIFT_FILE: &str = "apple_intelligence_stub.swift";
+    const BRIDGE_HEADER: &str = "apple_intelligence_bridge.h";
+
+    println!("cargo:rerun-if-changed={REAL_SWIFT_FILE}");
+    println!("cargo:rerun-if-changed={STUB_SWIFT_FILE}");
+    println!("cargo:rerun-if-changed={BRIDGE_HEADER}");
+
+    let out_dir = PathBuf::from(env::var("OUT_DIR").expect("OUT_DIR not set"));
+    let object_path = out_dir.join("apple_intelligence.o");
+    let static_lib_path = out_dir.join("libapple_intelligence.a");
+
+    let sdk_path = String::from_utf8(
+        Command::new("xcrun")
+            .args(["--sdk", "macosx", "--show-sdk-path"])
+            .output()
+            .expect("Failed to locate macOS SDK")
+            .stdout,
+    )
+    .expect("SDK path is not valid UTF-8")
+    .trim()
+    .to_string();
+
+    // Check if the SDK supports FoundationModels (required for Apple Intelligence)
+    let framework_path = Path::new(&sdk_path)
+        .join("System/Library/Frameworks/FoundationModels.framework");
+    let has_foundation_models = framework_path.exists();
+
+    let source_file = if has_foundation_models {
+        println!("cargo:warning=Building with Apple Intelligence support.");
+        REAL_SWIFT_FILE
+    } else {
+        println!("cargo:warning=Apple Intelligence SDK not found. Building with stubs.");
+        STUB_SWIFT_FILE
+    };
+
+    if !Path::new(source_file).exists() {
+        panic!("Source file {} is missing!", source_file);
+    }
+
+    let swiftc_path = String::from_utf8(
+        Command::new("xcrun")
+            .args(["--find", "swiftc"])
+            .output()
+            .expect("Failed to locate swiftc")
+            .stdout,
+    )
+    .expect("swiftc path is not valid UTF-8")
+    .trim()
+    .to_string();
+
+    let toolchain_swift_lib = Path::new(&swiftc_path)
+        .parent()
+        .and_then(|p| p.parent())
+        .map(|root| root.join("lib/swift/macosx"))
+        .expect("Unable to determine Swift toolchain lib directory");
+    let sdk_swift_lib = Path::new(&sdk_path).join("usr/lib/swift");
+
+    let status = Command::new("xcrun")
+        .args([
+            "swiftc",
+            "-target",
+            "arm64-apple-macosx15.0",
+            "-sdk",
+            &sdk_path,
+            "-O",
+            "-import-objc-header",
+            BRIDGE_HEADER,
+            "-c",
+            source_file,
+            "-o",
+            object_path
+                .to_str()
+                .expect("Failed to convert object path to string"),
+        ])
+        .status()
+        .expect("Failed to invoke swiftc for Apple Intelligence bridge");
+
+    if !status.success() {
+        panic!("swiftc failed to compile {source_file}");
+    }
+
+    let status = Command::new("libtool")
+        .args([
+            "-static",
+            "-o",
+            static_lib_path
+                .to_str()
+                .expect("Failed to convert static lib path to string"),
+            object_path
+                .to_str()
+                .expect("Failed to convert object path to string"),
+        ])
+        .status()
+        .expect("Failed to create static library for Apple Intelligence bridge");
+
+    if !status.success() {
+        panic!("libtool failed for Apple Intelligence bridge");
+    }
+
+    println!("cargo:rustc-link-search=native={}", out_dir.display());
+    println!("cargo:rustc-link-lib=static=apple_intelligence");
+    println!(
+        "cargo:rustc-link-search=native={}",
+        toolchain_swift_lib.display()
+    );
+    println!("cargo:rustc-link-search=native={}", sdk_swift_lib.display());
+    println!("cargo:rustc-link-lib=framework=Foundation");
+
+    if has_foundation_models {
+        println!("cargo:rustc-link-lib=framework=FoundationModels");
+    }
+
+    println!("cargo:rustc-link-arg=-Wl,-rpath,/usr/lib/swift");
+}