feat: add AppImageHub provider support

crates/aim-core/tests/adapter_contract.rs

@@ -1,3 +1,4 @@
+use aim_core::adapters::appimagehub::AppImageHubAdapter;
 use aim_core::adapters::direct_url::DirectUrlAdapter;
 use aim_core::adapters::github::GitHubAdapter;
 use aim_core::adapters::gitlab::GitLabAdapter;
@@ -9,6 +10,7 @@ use aim_core::app::query::resolve_query;
 use aim_core::domain::source::{
     NormalizedSourceKind, ResolvedRelease, SourceInputKind, SourceKind, SourceRef,
 };
+use aim_core::source::appimagehub::FixtureAppImageHubTransport;
 
 struct FileArtifactAdapter;
 
@@ -59,6 +61,60 @@ fn adapter_capabilities_can_report_exact_resolution_only() {
     assert!(!capabilities.supports_search);
 }
 
+#[test]
+fn appimagehub_adapter_reports_search_and_exact_resolution_capabilities() {
+    let adapter = AppImageHubAdapter;
+
+    assert_eq!(adapter.id(), "appimagehub");
+    assert_eq!(
+        adapter.repository_source_kind(),
+        Some(SourceKind::AppImageHub)
+    );
+    assert_eq!(adapter.exact_source_kind(), None);
+    assert_eq!(
+        adapter.capabilities(),
+        AdapterCapabilities {
+            supports_search: true,
+            supports_exact_resolution: true,
+        }
+    );
+}
+
+#[test]
+fn appimagehub_adapter_resolves_installable_items_through_fixture_transport() {
+    let adapter = AppImageHubAdapter;
+    let source = resolve_query("appimagehub/2338455").unwrap();
+
+    let resolution = adapter
+        .resolve_source_with(&source, &FixtureAppImageHubTransport)
+        .unwrap();
+
+    assert!(matches!(
+        resolution,
+        AdapterResolveOutcome::Resolved(AdapterResolution {
+            source,
+            release: ResolvedRelease { version, .. },
+        }) if source.kind == SourceKind::AppImageHub
+            && source.canonical_locator.as_deref() == Some("2338455")
+            && version == "latest"
+    ));
+}
+
+#[test]
+fn appimagehub_adapter_reports_no_installable_artifact_for_non_appimage_items() {
+    let adapter = AppImageHubAdapter;
+    let source = resolve_query("appimagehub/2337998").unwrap();
+
+    let resolution = adapter
+        .resolve_source_with(&source, &FixtureAppImageHubTransport)
+        .unwrap();
+
+    assert_eq!(
+        resolution,
+        AdapterResolveOutcome::NoInstallableArtifact { source }
+    );
+}
+
 #[test]
 fn repository_backed_resolvers_accept_only_their_own_source_kind() {
     let github_source = resolve_query("sharkdp/bat").unwrap();

crates/aim-core/tests/adapter_smoke.rs

@@ -4,10 +4,11 @@ use aim_core::adapters::all_adapter_kinds;
 fn all_expected_adapter_kinds_are_registered() {
     let kinds = all_adapter_kinds();
 
+    assert!(kinds.contains(&"appimagehub"));
     assert!(kinds.contains(&"github"));
     assert!(kinds.contains(&"gitlab"));
     assert!(kinds.contains(&"direct-url"));
     assert!(kinds.contains(&"zsync"));
     assert!(kinds.contains(&"sourceforge"));
-    assert!(kinds.contains(&"custom-json"));
+    assert!(!kinds.contains(&"custom-json"));
 }

crates/aim-core/tests/appimagehub_search.rs

@@ -0,0 +1,108 @@
+use aim_core::app::search::{
+    AppImageHubSearchProvider, GitHubSearchProvider, SearchProvider, SearchProviderError,
+    build_search_results_with,
+};
+use aim_core::domain::app::AppRecord;
+use aim_core::domain::search::{SearchInstallStatus, SearchQuery, SearchResult};
+use aim_core::domain::source::{NormalizedSourceKind, SourceInputKind, SourceKind, SourceRef};
+use aim_core::source::appimagehub::FixtureAppImageHubTransport;
+use aim_core::source::github::FixtureGitHubTransport;
+
+struct StubProvider {
+    hit: SearchResult,
+}
+
+impl SearchProvider for StubProvider {
+    fn search(&self, _query: &SearchQuery) -> Result<Vec<SearchResult>, SearchProviderError> {
+        Ok(vec![self.hit.clone()])
+    }
+}
+
+#[test]
+fn appimagehub_search_provider_maps_hits_to_install_ready_results() {
+    let provider = AppImageHubSearchProvider::new(&FixtureAppImageHubTransport);
+
+    let results = provider.search(&SearchQuery::new("firefox")).unwrap();
+
+    assert!(results.iter().any(|hit| {
+        hit.provider_id == "appimagehub"
+            && hit.display_name == "Firefox by Mozilla - Official AppImage Edition"
+            && hit.install_query == "appimagehub/2338455"
+            && hit.canonical_locator == "2338455"
+    }));
+}
+
+#[test]
+fn appimagehub_hits_are_annotated_as_installed_by_canonical_id() {
+    let provider = AppImageHubSearchProvider::new(&FixtureAppImageHubTransport);
+    let installed = vec![AppRecord {
+        stable_id: "firefox".to_owned(),
+        display_name: "Firefox by Mozilla - Official AppImage Edition".to_owned(),
+        source_input: Some("appimagehub/2338455".to_owned()),
+        source: Some(SourceRef {
+            kind: SourceKind::AppImageHub,
+            locator: "https://www.appimagehub.com/p/2338455".to_owned(),
+            input_kind: SourceInputKind::AppImageHubShorthand,
+            normalized_kind: NormalizedSourceKind::AppImageHub,
+            canonical_locator: Some("2338455".to_owned()),
+            requested_tag: None,
+            requested_asset_name: None,
+            tracks_latest: true,
+        }),
+        installed_version: Some("latest".to_owned()),
+        update_strategy: None,
+        metadata: Vec::new(),
+        install: None,
+    }];
+
+    let results =
+        build_search_results_with(&SearchQuery::new("firefox"), &installed, &[&provider]).unwrap();
+
+    assert!(results.remote_hits.iter().any(|hit| {
+        hit.canonical_locator == "2338455"
+            && matches!(
+                hit.install_status,
+                SearchInstallStatus::Installed {
+                    installed_version: Some(ref version)
+                } if version == "latest"
+            )
+    }));
+}
+
+#[test]
+fn search_can_merge_github_and_appimagehub_providers() {
+    let github = GitHubSearchProvider::new(&FixtureGitHubTransport);
+    let appimagehub = AppImageHubSearchProvider::new(&FixtureAppImageHubTransport);
+    let stub = StubProvider {
+        hit: SearchResult {
+            provider_id: "github".to_owned(),
+            display_name: "firefox-tooling/firestarter".to_owned(),
+            description: Some("Stub GitHub result".to_owned()),
+            source_locator: "https://github.com/firefox-tooling/firestarter".to_owned(),
+            install_query: "firefox-tooling/firestarter".to_owned(),
+            canonical_locator: "firefox-tooling/firestarter".to_owned(),
+            version: Some("1.0.0".to_owned()),
+            install_status: SearchInstallStatus::Available,
+        },
+    };
+
+    let results = build_search_results_with(
+        &SearchQuery::new("firefox"),
+        &[],
+        &[&stub, &github, &appimagehub],
+    )
+    .unwrap();
+
+    assert!(
+        results
+            .remote_hits
+            .iter()
+            .any(|hit| hit.provider_id == "github")
+    );
+    assert!(
+        results
+            .remote_hits
+            .iter()
+            .any(|hit| hit.provider_id == "appimagehub")
+    );
+}

crates/aim-core/tests/query_resolution.rs

@@ -26,6 +26,29 @@ fn classifies_github_release_asset_url() {
     );
 }
 
+#[test]
+fn classifies_appimagehub_item_url() {
+    let source = resolve_query("https://www.appimagehub.com/p/2338455").unwrap();
+
+    assert_eq!(source.kind, SourceKind::AppImageHub);
+    assert_eq!(source.input_kind, SourceInputKind::AppImageHubUrl);
+    assert_eq!(source.normalized_kind, NormalizedSourceKind::AppImageHub);
+    assert_eq!(source.canonical_locator.as_deref(), Some("2338455"));
+    assert!(source.tracks_latest);
+}
+
+#[test]
+fn classifies_appimagehub_id_shorthand() {
+    let source = resolve_query("appimagehub/2338455").unwrap();
+
+    assert_eq!(source.kind, SourceKind::AppImageHub);
+    assert_eq!(source.input_kind, SourceInputKind::AppImageHubShorthand);
+    assert_eq!(source.normalized_kind, NormalizedSourceKind::AppImageHub);
+    assert_eq!(source.locator, "https://www.appimagehub.com/p/2338455");
+    assert_eq!(source.canonical_locator.as_deref(), Some("2338455"));
+    assert!(source.tracks_latest);
+}
+
 #[test]
 fn classifies_gitlab_repository_url() {
     let source = resolve_query("https://gitlab.com/example/team-app").unwrap();
@@ -278,6 +301,13 @@ fn rejects_malformed_sourceforge_url() {
     assert_eq!(error, aim_core::app::query::ResolveQueryError::Unsupported);
 }
 
+#[test]
+fn rejects_malformed_appimagehub_shorthand() {
+    let error = resolve_query("appimagehub/firefox").unwrap_err();
+
+    assert_eq!(error, aim_core::app::query::ResolveQueryError::Unsupported);
+}
+
 #[test]
 fn rejects_unsupported_sourceforge_url_shape() {
     let error = resolve_query("https://sourceforge.net/projects/team-app/rss").unwrap_err();