Skip to main content

offline_registry/
lib.rs

1//! # offline-registry
2//!
3//! The knowledge core of the Offline Protocol CLI and MCP server: package
4//! manifests, skill documents, workflow definitions, and starter-template
5//! metadata, embedded into the binary and queryable offline.
6
7pub mod example_apps;
8pub mod intent;
9pub mod llms;
10pub mod model;
11pub mod plan;
12pub mod resolve;
13pub mod search;
14pub mod search_index;
15pub mod store;
16
17pub use example_apps::{is_example_app_template, EXAMPLE_APP_TEMPLATE_IDS};
18pub use intent::{classify_entrance, entrance_scores, mentions_existing_app, IntentMatch};
19pub use model::{
20    Architecture, Capability, CapabilityTerms, Example, PackageManifest, Skill, TemplateMeta,
21    TemplateVariable, Workflow,
22};
23pub use plan::{
24    architecture_markdown, classify_p2p, classify_p2p_app_kind, classify_p2p_profile,
25    implementation_plan_markdown, normalize_platform, platform_label, restate_platform,
26    unsupported_framework, P2pProfile, Plan, BROWSER_NOTE, PACKAGE_ONLY_PLATFORMS,
27};
28pub use resolve::{Resolution, ResolvedPackage};
29pub use search::SearchHit;
30pub use store::{Registry, RegistrySource, REGISTRY_DIR_ENV};
31
32/// npm package that ships the `offline` binary and its MCP server.
33pub const CLI_NPM_PACKAGE: &str = "@offline-protocol/cli";
34
35/// Version of this build. The npm package is published at the same version.
36pub const CLI_VERSION: &str = env!("CARGO_PKG_VERSION");
37
38/// Command and arguments that start this release's stdio MCP server through
39/// npx, so generated project configs work without a global `offline` install.
40pub fn mcp_serve_command() -> (&'static str, Vec<String>) {
41    (
42        "npx",
43        vec![
44            "-y".to_string(),
45            format!("{CLI_NPM_PACKAGE}@{CLI_VERSION}"),
46            "mcp".to_string(),
47            "serve".to_string(),
48        ],
49    )
50}
51
52/// [`mcp_serve_command`] as one shell line, for docs and agent guidance.
53pub fn mcp_serve_command_line() -> String {
54    let (cmd, args) = mcp_serve_command();
55    format!("{cmd} {}", args.join(" "))
56}
57
58#[derive(Debug, thiserror::Error)]
59pub enum RegistryError {
60    #[error("registry source not found: {0}")]
61    SourceNotFound(String),
62    #[error("failed to read {0}: {1}")]
63    Io(String, #[source] std::io::Error),
64    #[error("failed to parse {0}: {1}")]
65    Parse(String, String),
66    #[error("registry validation failed: {0}")]
67    Validation(String),
68    #[error("not found: {0}")]
69    NotFound(String),
70    #[error("incompatible: {0}")]
71    Incompatible(String),
72}
73
74#[cfg(test)]
75mod tests {
76    use super::*;
77
78    fn reg() -> Registry {
79        Registry::load_embedded().expect("embedded registry loads")
80    }
81
82    #[test]
83    fn plan_offline_id_mesh_chat_selects_workflow() {
84        let r = reg();
85        let plan = r
86            .plan("Create a React Native mesh chat app using Offline ID", None)
87            .expect("plan succeeds");
88        assert_eq!(plan.workflow, "offline-id-mesh-chat");
89        assert_eq!(plan.platform, "react-native");
90    }
91
92    #[test]
93    fn resolve_offline_id_mesh_chat_includes_both_sdks() {
94        let r = reg();
95        let res = r
96            .resolve_workflow("offline-id-mesh-chat", "react-native")
97            .expect("offline-id-mesh-chat resolves on react-native");
98        let names: Vec<&str> = res.packages.iter().map(|p| p.name.as_str()).collect();
99        assert!(names.contains(&"@offline-protocol/id-react-native"));
100        assert!(names.contains(&"@offline-protocol/mesh-sdk"));
101    }
102
103    #[test]
104    fn plan_offline_id_mesh_group_chat_selects_workflow() {
105        let r = reg();
106        let plan = r
107            .plan("Build a BLE group chat app with Offline ID and mesh", None)
108            .expect("plan succeeds");
109        assert_eq!(plan.workflow, "offline-id-mesh-chat");
110        assert!(plan.capabilities.contains(&"group-messaging".to_string()));
111    }
112
113    #[test]
114    fn plan_nearby_group_chat_selects_nearby_or_group_workflow() {
115        let r = reg();
116        let plan = r
117            .plan("Nearby BLE group chat without accounts", None)
118            .expect("plan succeeds");
119        assert!(
120            plan.workflow == "nearby-chat" || plan.workflow == "group-messaging",
121            "expected nearby-chat or group-messaging, got {}",
122            plan.workflow
123        );
124        assert!(plan.capabilities.contains(&"group-messaging".to_string()));
125    }
126
127    #[test]
128    fn embedded_registry_loads_and_validates() {
129        let r = reg();
130        assert!(r.packages().count() >= 6, "expected at least 6 packages");
131        assert!(r.workflows().count() >= 6, "expected at least 6 workflows");
132        assert!(r.skills().count() >= 13, "expected at least 13 skills");
133        assert!(r.templates().count() >= 6, "expected at least 6 templates");
134    }
135
136    #[test]
137    fn search_finds_mesh_sdk_for_peer_discovery() {
138        let r = reg();
139        let hits = r.search_packages("peer discovery offline chat");
140        assert!(!hits.is_empty());
141        assert_eq!(hits[0].name, "@offline-protocol/mesh-sdk");
142    }
143
144    fn top_capabilities(r: &Registry, query: &str, n: usize) -> Vec<String> {
145        r.search_capabilities(query)
146            .into_iter()
147            .take(n)
148            .map(|h| h.name)
149            .collect()
150    }
151
152    #[test]
153    fn capability_search_matches_the_words_developers_type() {
154        let r = reg();
155        let cases: &[(&str, &[&str])] = &[
156            ("bluetooth", &["mesh-networking", "peer-discovery"]),
157            ("ble", &["mesh-networking", "peer-discovery"]),
158            ("nearby", &["peer-discovery", "service-discovery"]),
159            ("offline messaging", &["offline-messaging"]),
160            ("sign in", &["identity"]),
161            ("login", &["identity"]),
162            ("wifi", &["mesh-networking", "transport-fallback"]),
163            ("internet", &["mesh-networking", "transport-fallback"]),
164            ("p2p", &["mesh-networking"]),
165            ("avatar", &["identicons"]),
166            ("who is here", &["peer-discovery", "presence"]),
167            // SDK 0.28.0 platforms and features.
168            ("python", &["server-runtime"]),
169            ("swift", &["native-mobile"]),
170            ("kotlin", &["native-mobile"]),
171            ("android native", &["native-mobile"]),
172            ("esp32", &["embedded-leaf"]),
173            ("local api", &["local-api"]),
174            ("custody", &["custody"]),
175            ("wi-fi direct", &["mesh-networking"]),
176            // SDK 0.29.0: the HTTP front and the verifier.
177            ("http", &["http-front"]),
178            ("curl", &["http-front"]),
179            ("docker", &["http-front"]),
180            ("offline-protocol-verify", &["local-api"]),
181            // SDK 0.30.0: the Flutter plugin, Java and the C API.
182            ("flutter", &["native-mobile"]),
183            ("dart", &["native-mobile"]),
184            ("java", &["server-runtime"]),
185            ("jvm", &["server-runtime"]),
186            ("cgo", &["server-runtime"]),
187            // SDK 0.31.0: the Ruby binding and the browser engine.
188            ("ruby", &["server-runtime"]),
189            ("rubygems", &["server-runtime"]),
190            ("webrtc", &["browser-node"]),
191            ("web worker", &["browser-node"]),
192            ("opfs", &["browser-node"]),
193            ("rssi", &["peer-discovery"]),
194            // SDK 0.32.0: service subscriptions and the C# binding.
195            ("subscribe to a service", &["service-subscriptions"]),
196            ("pubsub", &["service-subscriptions"]),
197            ("csharp", &["server-runtime"]),
198            ("dotnet", &["server-runtime"]),
199        ];
200        for (query, expected) in cases {
201            let top = top_capabilities(&r, query, 3);
202            for name in *expected {
203                assert!(top.iter().any(|t| t == name), "{query}: {top:?}");
204            }
205        }
206        assert_eq!(
207            top_capabilities(&r, "offline messaging", 1),
208            ["offline-messaging"]
209        );
210    }
211
212    #[test]
213    fn capability_search_ranks_mesh_first_for_a_plain_sentence() {
214        let r = reg();
215        let hits = r.search_capabilities(
216            "phones near each other share data over Bluetooth without wifi or server",
217        );
218        let first = &hits.first().expect("capability hits").name;
219        assert!(
220            ["mesh-networking", "peer-discovery"].contains(&first.as_str()),
221            "{hits:?}"
222        );
223        let mesh = r.package("@offline-protocol/mesh-sdk").unwrap();
224        for hit in hits.iter().take(3) {
225            assert!(mesh.capabilities.contains(&hit.name), "{hits:?}");
226        }
227    }
228
229    #[test]
230    fn search_ignores_stopwords() {
231        let r = reg();
232        // "of" and "in" used to prefix-match "offline" and "invocation".
233        let location = top_capabilities(&r, "proof of location", 10);
234        assert_eq!(location, ["proof-of-location", "location-proofs"]);
235        assert!(!top_capabilities(&r, "sign in", 10).contains(&"service-invocation".to_string()));
236        assert!(r.search_capabilities("the of in on or").is_empty());
237        assert!(r.search_packages("each other without the").is_empty());
238    }
239
240    #[test]
241    fn every_capability_has_curated_search_keywords() {
242        let r = reg();
243        for cap in r.capabilities() {
244            let terms = r.capability_terms.get(&cap.name);
245            assert!(
246                terms.is_some_and(|t| !t.keywords.is_empty()),
247                "add `{}` to registry/capabilities.json",
248                cap.name
249            );
250        }
251    }
252
253    #[test]
254    fn capability_keywords_for_unknown_capabilities_are_rejected() {
255        let dir =
256            std::env::temp_dir().join(format!("offline-registry-capterms-{}", std::process::id()));
257        let _ = std::fs::remove_dir_all(&dir);
258        std::fs::create_dir_all(dir.join("packages")).unwrap();
259        std::fs::write(
260            dir.join("packages/demo.json"),
261            r#"{"name":"demo","version":"1.0.0","description":"d","platforms":["web"],"license":"MIT","capabilities":["demo-cap"]}"#,
262        )
263        .unwrap();
264        std::fs::write(
265            dir.join("capabilities.json"),
266            r#"{"demo-cap":{"keywords":["demo"]}}"#,
267        )
268        .unwrap();
269        let ok = Registry::load_from_dir(&dir).expect("known capability loads");
270        assert_eq!(top_capabilities(&ok, "demo", 1), ["demo-cap"]);
271        std::fs::write(
272            dir.join("capabilities.json"),
273            r#"{"missing-cap":{"keywords":["demo"]}}"#,
274        )
275        .unwrap();
276        let err = Registry::load_from_dir(&dir)
277            .err()
278            .expect("unknown capability fails");
279        let _ = std::fs::remove_dir_all(&dir);
280        assert!(matches!(err, RegistryError::Validation(_)), "{err}");
281    }
282
283    #[test]
284    fn sdk_packages_share_the_release_pin() {
285        let r = reg();
286        let pin = &r.package("@offline-protocol/mesh-sdk").unwrap().version;
287        assert_eq!(pin, "0.34.0");
288        // offline-protocol-swift is tagged by the Swift repository's own
289        // scheduled publish, after the SDK release; it stays on the newest tag
290        // that exists until that run, then rejoins the shared pin.
291        assert_eq!(
292            r.package("offline-protocol-swift").unwrap().version,
293            "0.33.0"
294        );
295        for name in [
296            "offline-protocol-sdk",
297            "offline-protocol-android",
298            "offline-protocol",
299            "offline-protocol-leaf",
300            "offline-protocol-java",
301            "offline-protocol-c",
302            "offline-protocol-flutter",
303            "offline-protocol-ruby",
304            "offline-protocol-web",
305            "offline-protocol-csharp",
306        ] {
307            let p = r.package(name).unwrap_or_else(|| panic!("{name} missing"));
308            assert_eq!(&p.version, pin, "{name}");
309        }
310        // The previews say so wherever they are resolved.
311        for name in [
312            "offline-protocol-swift",
313            "offline-protocol-android",
314            "offline-protocol-leaf",
315            "offline-protocol-flutter",
316            "offline-protocol-csharp",
317        ] {
318            assert_eq!(r.package(name).unwrap().status, "preview", "{name}");
319        }
320        assert_eq!(
321            r.package("offline-protocol-web").unwrap().status,
322            "experimental"
323        );
324    }
325
326    #[test]
327    fn package_only_platforms_install_from_their_own_channels() {
328        let r = reg();
329        let cmds = |name: &str, platform: &str| {
330            r.resolve_packages(&[name.to_string()], platform)
331                .unwrap()
332                .install_commands
333                .join("\n")
334        };
335        assert_eq!(
336            cmds("offline-protocol-sdk", "python"),
337            "pip install offline-protocol-sdk==0.34.0"
338        );
339        assert_eq!(
340            cmds("offline-protocol", "rust"),
341            "cargo add offline-protocol@0.34.0"
342        );
343        assert!(cmds("offline-protocol-swift", "ios-native").contains(
344            "https://github.com/Offline-Protocol/offline-protocol-swift.git\", from: \"0.33.0\""
345        ));
346        assert_eq!(
347            cmds("offline-protocol-android", "android-native"),
348            "implementation(\"com.offlineprotocol:offline-protocol-sdk:0.34.0\")"
349        );
350        assert!(cmds("offline-protocol-leaf", "embedded")
351            .starts_with("cargo add offline-protocol-leaf@0.34.0 --no-default-features"));
352        // SDK 0.30.0: Java on Maven Central, the C API from the release
353        // archives, and the Flutter plugin from a checkout.
354        assert_eq!(
355            cmds("offline-protocol-java", "java"),
356            "implementation(\"com.offlineprotocol:offline-protocol-java:0.34.0\")"
357        );
358        let c = cmds("offline-protocol-c", "c");
359        assert!(
360            c.contains("releases/tag/v0.34.0") && c.contains("-loffline_protocol_uniffi"),
361            "{c}"
362        );
363        let flutter = cmds("offline-protocol-flutter", "flutter");
364        assert!(
365            flutter.contains("v0.34.0") && flutter.contains("bindings/flutter/offline_protocol"),
366            "{flutter}"
367        );
368        assert!(!flutter.contains("flutter pub add"), "{flutter}");
369        // SDK 0.31.0: the Ruby gem on RubyGems, and the browser engine (the
370        // crate on crates.io, the JavaScript client from a checkout).
371        let ruby = cmds("offline-protocol-ruby", "ruby");
372        assert!(
373            ruby.starts_with("gem \"offline_protocol\", \"~> 0.34.0\"")
374                && ruby.contains("releases/tag/v0.34.0"),
375            "{ruby}"
376        );
377        let web = cmds("offline-protocol-web", "nextjs");
378        assert!(
379            web.contains("v0.34.0")
380                && web.contains("bindings/web/scripts/build.sh")
381                && web.contains("cargo add offline-protocol-web@0.34.0"),
382            "{web}"
383        );
384        assert!(!web.contains("npm install"), "{web}");
385        // SDK 0.32.0: the C# binding, a project reference from a checkout.
386        let csharp = cmds("offline-protocol-csharp", "csharp");
387        assert!(
388            csharp.contains("v0.34.0")
389                && csharp
390                    .contains("bindings/csharp/src/OfflineProtocol.Sdk/OfflineProtocol.Sdk.csproj")
391                && csharp.contains("offline-protocol-0.34.0-<platform>"),
392            "{csharp}"
393        );
394        assert!(!csharp.contains("dotnet add package"), "{csharp}");
395        let err = r
396            .resolve_packages(&["offline-protocol-sdk".to_string()], "react-native")
397            .unwrap_err();
398        assert!(err.to_string().contains("[python]"), "{err}");
399    }
400
401    #[test]
402    fn plans_name_the_packages_of_a_platform_without_workflows() {
403        let r = reg();
404        // Python plans nearby chat now (template python-mesh-chat).
405        let python = r.plan("nearby chat", Some("python")).unwrap();
406        assert_eq!(python.workflow, "nearby-chat");
407        assert_eq!(python.template.as_deref(), Some("python-mesh-chat"));
408        // So does Java (template kotlin-mesh-chat).
409        let java = r.plan("nearby chat", Some("jvm")).unwrap();
410        assert_eq!(java.workflow, "nearby-chat");
411        assert_eq!(java.template.as_deref(), Some("kotlin-mesh-chat"));
412        for (platform, package) in [
413            ("swift", "offline-protocol-swift 0.33.0 (preview)"),
414            ("kotlin", "offline-protocol-android 0.34.0 (preview)"),
415            ("esp32", "offline-protocol-leaf 0.34.0 (preview)"),
416            ("rust", "offline-protocol 0.34.0 (stable)"),
417            ("flutter", "offline-protocol-flutter 0.34.0 (preview)"),
418            ("c", "offline-protocol-c 0.34.0 (stable)"),
419            ("ruby", "offline-protocol-ruby 0.34.0 (stable)"),
420            ("csharp", "offline-protocol-csharp 0.34.0 (preview)"),
421        ] {
422            let err = r
423                .plan("nearby chat", Some(platform))
424                .unwrap_err()
425                .to_string();
426            assert!(err.contains("no plan generated"), "{err}");
427            assert!(err.contains(package), "{platform}: {err}");
428        }
429        for (prompt, needle) in [
430            (
431                "native iOS app for nearby chat",
432                "offline-protocol-swift 0.33.0",
433            ),
434            ("A SwiftUI app with offline messaging", "early preview"),
435            (
436                "Native Android Kotlin app that sends files over Wi-Fi Direct",
437                "com.offlineprotocol:offline-protocol-sdk",
438            ),
439        ] {
440            let err = r.plan(prompt, None).unwrap_err().to_string();
441            assert!(err.contains(needle), "{prompt}: {err}");
442        }
443        // SDK 0.30.0: a Flutter or Java prompt names its package, still
444        // without a plan.
445        for (prompt, needle) in [
446            (
447                "A Flutter app for nearby chat",
448                "offline-protocol-flutter 0.34.0",
449            ),
450            ("A Flutter app for nearby chat", "not on pub.dev"),
451            (
452                "A Java desktop app for nearby chat",
453                "com.offlineprotocol:offline-protocol-java",
454            ),
455            // SDK 0.31.0.
456            (
457                "A Ruby service that relays messages",
458                "offline_protocol gem",
459            ),
460            ("A Flutter app for nearby chat", "MeshSdk"),
461            // SDK 0.32.0.
462            (
463                "A C# desktop app for nearby chat",
464                "offline-protocol-csharp",
465            ),
466            ("A .NET service that relays messages", "not on NuGet"),
467        ] {
468            let err = r.plan(prompt, None).unwrap_err().to_string();
469            assert!(err.contains("no plan generated"), "{prompt}: {err}");
470            assert!(err.contains(needle), "{prompt}: {err}");
471        }
472        // Frameworks with no package at all keep the plain answer.
473        let err = r
474            .plan("A Xamarin app for nearby chat", None)
475            .unwrap_err()
476            .to_string();
477        assert!(err.contains("There is no Xamarin package"), "{err}");
478    }
479
480    #[test]
481    fn package_registry_and_install_are_validated() {
482        let dir =
483            std::env::temp_dir().join(format!("offline-registry-install-{}", std::process::id()));
484        let _ = std::fs::remove_dir_all(&dir);
485        std::fs::create_dir_all(dir.join("packages")).unwrap();
486        let write = |body: &str| std::fs::write(dir.join("packages/demo.json"), body).unwrap();
487        let load = || Registry::load_from_dir(&dir);
488
489        write(
490            r#"{"name":"demo","version":"1.0.0","description":"d","platforms":["python"],"registry":"pypi","license":"MIT"}"#,
491        );
492        assert!(load().is_ok());
493        write(
494            r#"{"name":"demo","version":"1.0.0","description":"d","platforms":["ios-native"],"registry":"swiftpm","license":"MIT"}"#,
495        );
496        assert!(load()
497            .err()
498            .unwrap()
499            .to_string()
500            .contains("needs an `install`"));
501        write(
502            r#"{"name":"demo","version":"1.0.0","description":"d","platforms":["ios-native"],"registry":"swiftpm","install":"from: 0.9.0","license":"MIT"}"#,
503        );
504        assert!(load()
505            .err()
506            .unwrap()
507            .to_string()
508            .contains("does not name version 1.0.0"));
509        write(
510            r#"{"name":"demo","version":"1.0.0","description":"d","platforms":["android-native"],"registry":"maven","license":"MIT"}"#,
511        );
512        assert!(load()
513            .err()
514            .unwrap()
515            .to_string()
516            .contains("needs an `install`"));
517        write(
518            r#"{"name":"demo","version":"1.0.0","description":"d","platforms":["python"],"registry":"conda","license":"MIT"}"#,
519        );
520        assert!(load()
521            .err()
522            .unwrap()
523            .to_string()
524            .contains("unknown registry"));
525        write(
526            r#"{"name":"demo","version":"1.0.0","description":"d","platforms":["flutter"],"registry":"source","license":"MIT"}"#,
527        );
528        assert!(load()
529            .err()
530            .unwrap()
531            .to_string()
532            .contains("needs an `install`"));
533        write(
534            r#"{"name":"demo","version":"1.0.0","description":"d","platforms":["xamarin"],"license":"MIT"}"#,
535        );
536        assert!(load()
537            .err()
538            .unwrap()
539            .to_string()
540            .contains("unknown platform"));
541        let _ = std::fs::remove_dir_all(&dir);
542    }
543
544    #[test]
545    fn resolve_workflow_includes_transitive_requirements() {
546        let r = reg();
547        let res = r
548            .resolve_workflow("offline-social-network", "react-native")
549            .expect("offline-social-network resolves on react-native");
550        let names: Vec<&str> = res.packages.iter().map(|p| p.name.as_str()).collect();
551        assert!(names.contains(&"@offline-protocol/id-react-native"));
552        // id-react-native requires core
553        assert!(names.contains(&"@offline-protocol/core"));
554        assert!(!res.install_commands.is_empty());
555    }
556
557    #[test]
558    fn resolve_rejects_wrong_platform() {
559        let r = reg();
560        let err = r
561            .resolve_packages(&["@offline-protocol/id-react".to_string()], "react-native")
562            .unwrap_err();
563        assert!(matches!(err, RegistryError::Incompatible(_)));
564    }
565
566    #[test]
567    fn plan_local_social_app_selects_offline_social_network() {
568        let r = reg();
569        let plan = r
570            .plan("Build an offline social network with feed", None)
571            .expect("plan succeeds");
572        assert_eq!(plan.workflow, "offline-social-network");
573        assert!(!plan.resolution.packages.is_empty());
574        let md = architecture_markdown(&plan);
575        assert!(md.contains("offline-social-network"));
576        let ip = implementation_plan_markdown(&plan);
577        assert!(ip.contains("offline doctor"));
578    }
579
580    #[test]
581    fn plan_custom_p2p_game_selects_custom_workflow() {
582        let r = reg();
583        let plan = r
584            .plan(
585                "Build a tic tac toe game two phones can play over BLE",
586                None,
587            )
588            .expect("plan succeeds");
589        assert_eq!(plan.workflow, "custom-p2p-app");
590        assert_eq!(plan.platform, "react-native");
591        assert_eq!(
592            plan.template.as_deref(),
593            Some("react-native-mesh-custom-app")
594        );
595        let p2p = plan.p2p_profile.as_ref().expect("p2p profile present");
596        assert_eq!(p2p.sync_model, "host-authority");
597        assert_eq!(p2p.discovery, "mesh-services");
598        assert_eq!(p2p.app_kind, "tic-tac-toe");
599        assert!(plan.skills.contains(&"p2p-app-architecture".to_string()));
600        let md = architecture_markdown(&plan);
601        assert!(md.contains("## P2P profile"));
602        assert!(md.contains("host-authority"));
603    }
604
605    #[test]
606    fn plan_custom_p2p_file_share_classifies_request_response() {
607        let r = reg();
608        let plan = r
609            .plan("Nearby file transfer app to share photos offline", None)
610            .expect("plan succeeds");
611        assert_eq!(plan.workflow, "custom-p2p-app");
612        let p2p = plan.p2p_profile.as_ref().expect("p2p profile present");
613        assert_eq!(p2p.sync_model, "request-response");
614        assert_eq!(p2p.app_kind, "generic");
615    }
616
617    /// The founder-review prompts and paraphrases, with the entrance each must select.
618    const ENTRANCE_PROMPTS: &[(&str, &str)] = &[
619        ("local-handoff", "Durable equipment handoff between field engineers, with persistence and backend reconciliation"),
620        ("local-handoff", "Hand over a work order from one technician's phone to another without signal and sync it to our backend later"),
621        ("local-handoff", "Shift change app: the outgoing crew passes custody of tools to the incoming crew, offline"),
622        ("local-handoff", "Chain of custody for evidence bags between officers, acknowledged on both devices"),
623        ("local-handoff", "Inspection results handed off between site operators with durable storage and later reconciliation"),
624        ("local-handoff", "Transfer responsibility for a pump from one field engineer's tablet to another with an acknowledgement"),
625        ("backend-delivery", "Retain sensor telemetry during outages and deliver it to a backend with explicit acceptance"),
626        ("backend-delivery", "Buffer IoT readings on the phone when the network drops and upload them to our API with idempotent retries"),
627        ("backend-delivery", "Store-and-forward pipeline for field inspection results into Kafka"),
628        ("backend-delivery", "Queue measurements offline and ingest them into our system of record once connectivity returns"),
629        ("backend-delivery", "Collect readings from nearby devices through a gateway phone and deliver them to the cloud"),
630        ("backend-delivery", "Keep device events during outages and push them to the server exactly once"),
631        ("nearby-service", "Discover and invoke an authorised nearby service from an existing application"),
632        ("nearby-service", "Let our existing app call a nearby printer's print capability over Bluetooth"),
633        ("nearby-service", "Query equipment diagnostics from a nearby device via RPC with authorization"),
634        ("nearby-service", "Expose a status service on one phone and let approved phones discover and call it"),
635        ("nearby-service", "Find a nearby provider and send it a request, then correlate the response"),
636        ("nearby-service", "Advertise a capability from a kiosk and invoke it from staff devices"),
637    ];
638
639    #[test]
640    fn plan_routes_entrance_prompts_to_their_workflows() {
641        let r = reg();
642        for (workflow, prompt) in ENTRANCE_PROMPTS {
643            let plan = r.plan(prompt, None).expect("plan succeeds");
644            assert_eq!(plan.workflow, *workflow, "{prompt}");
645            assert_eq!(plan.platform, "react-native", "{prompt}");
646            assert!(plan.p2p_profile.is_none(), "{prompt}");
647            assert_eq!(
648                plan.intent.as_ref().map(|i| i.workflow.as_str()),
649                Some(*workflow)
650            );
651            assert_eq!(
652                plan.skills,
653                r.workflow(workflow).unwrap().skills,
654                "{prompt}"
655            );
656            // Workflow search agrees with the planner.
657            assert_eq!(r.search_workflows(prompt)[0].name, *workflow, "{prompt}");
658        }
659    }
660
661    #[test]
662    fn entrance_plans_carry_their_template_and_guidance_not_games_or_chat() {
663        let r = reg();
664        let cases = [
665            ("Durable equipment handoff between field engineers, with persistence and backend reconciliation", "react-native-mesh-handoff", "local-handoff"),
666            ("Retain sensor telemetry during outages and deliver it to a backend with explicit acceptance", "react-native-mesh-event-delivery", "backend-delivery"),
667            ("Discover and invoke an authorised nearby service from an existing application", "react-native-mesh-service", "nearby-service"),
668        ];
669        for (prompt, template, skill) in cases {
670            let plan = r.plan(prompt, None).unwrap();
671            assert_eq!(plan.template.as_deref(), Some(template));
672            assert_eq!(plan.skills[0], skill);
673            let md = architecture_markdown(&plan);
674            let ip = implementation_plan_markdown(&plan);
675            assert!(md.contains("**Why this workflow:**"), "{md}");
676            for text in [&md, &ip] {
677                let lower = text.to_lowercase();
678                for banned in [
679                    "game",
680                    "tic-tac-toe",
681                    "chat thread",
682                    "groups list",
683                    "host/join",
684                    "create or join a session",
685                ] {
686                    assert!(!lower.contains(banned), "{template}: `{banned}` in\n{text}");
687                }
688            }
689            assert!(
690                ip.contains("Force quit") || ip.contains("outcome unknown"),
691                "{ip}"
692            );
693        }
694        let service = r.plan(cases[2].0, None).unwrap();
695        assert!(service.existing_app);
696        let md = architecture_markdown(&service);
697        assert!(md.contains("## Existing application"));
698        assert!(md.contains("attachServices"));
699        assert!(!r.plan(cases[0].0, None).unwrap().existing_app);
700    }
701
702    #[test]
703    fn explicit_game_chat_and_social_prompts_keep_their_workflows() {
704        let r = reg();
705        for (prompt, workflow) in [
706            (
707                "Build a tic tac toe game two phones can play over BLE",
708                "custom-p2p-app",
709            ),
710            ("offline Ludo for two phones", "custom-p2p-app"),
711            ("Nearby BLE group chat without accounts", "nearby-chat"),
712            (
713                "Build an offline social network with feed",
714                "offline-social-network",
715            ),
716            (
717                "Create a React Native mesh chat app using Offline ID",
718                "offline-id-mesh-chat",
719            ),
720            (
721                "Nearby file transfer app to share photos offline",
722                "custom-p2p-app",
723            ),
724            ("live poll at an event over BLE", "custom-p2p-app"),
725        ] {
726            let plan = r.plan(prompt, None).expect("plan succeeds");
727            assert_eq!(plan.workflow, workflow, "{prompt}");
728            assert!(plan.intent.is_none(), "{prompt}");
729        }
730    }
731
732    #[test]
733    fn unmatched_prompts_get_a_generic_shell_with_the_entrances_as_alternatives() {
734        let r = reg();
735        let plan = r.plan("qwerty zxcv", None).expect("plan succeeds");
736        assert_eq!(plan.workflow, "custom-p2p-app");
737        assert_eq!(plan.p2p_profile.as_ref().unwrap().app_kind, "generic");
738        let alternatives: Vec<&str> = plan
739            .alternatives
740            .iter()
741            .map(|a| a.workflow.as_str())
742            .collect();
743        assert_eq!(
744            alternatives,
745            ["local-handoff", "backend-delivery", "nearby-service"]
746        );
747        let md = architecture_markdown(&plan).to_lowercase();
748        assert!(!md.contains("game"), "{md}");
749    }
750
751    #[test]
752    fn workflow_skills_must_exist() {
753        let r = reg();
754        for wf in r.workflows() {
755            for skill in &wf.skills {
756                assert!(
757                    r.skill(skill).is_some(),
758                    "{} lists unknown skill {skill}",
759                    wf.name
760                );
761            }
762        }
763    }
764
765    #[test]
766    fn classify_p2p_app_kind_prefers_named_games() {
767        assert_eq!(classify_p2p_app_kind("offline Ludo for two phones"), "ludo");
768        assert_eq!(
769            classify_p2p_app_kind("Build a tic tac toe game over BLE"),
770            "tic-tac-toe"
771        );
772        assert_eq!(
773            classify_p2p_app_kind("two player board game nearby"),
774            "tic-tac-toe"
775        );
776        assert_eq!(
777            classify_p2p_app_kind("nearby file transfer for photos"),
778            "generic"
779        );
780        assert_eq!(classify_p2p_app_kind("custom P2P voting app"), "generic");
781    }
782
783    #[test]
784    fn classify_p2p_is_deterministic() {
785        let a = classify_p2p("live poll at an event over BLE");
786        let b = classify_p2p("live poll at an event over BLE");
787        assert_eq!(a.sync_model, "broadcast");
788        assert_eq!(a, b);
789    }
790
791    #[test]
792    fn plan_refuses_unsupported_frameworks_without_explicit_platform() {
793        let r = reg();
794        for prompt in [
795            "Build a Flutter app for kitchen order handoff over Bluetooth",
796            "Native Android Kotlin app that sends files over Wi-Fi Direct",
797            "native iOS app for nearby chat",
798            "Objective-C app with offline messaging",
799        ] {
800            let err = r.plan(prompt, None).unwrap_err();
801            assert!(matches!(err, RegistryError::Incompatible(_)), "{prompt}");
802            assert!(err.to_string().contains("no plan generated"), "{prompt}");
803        }
804        assert_eq!(
805            unsupported_framework("A community unity event app"),
806            Some("Unity")
807        );
808        assert_eq!(
809            unsupported_framework("React Native chat with a Swift native module"),
810            None
811        );
812        let plan = r
813            .plan("Flutter-style nearby chat", Some("react-native"))
814            .expect("explicit platform plans");
815        assert!(plan.resolution.warnings[0].contains("Flutter"));
816    }
817
818    #[test]
819    fn plan_restates_web_platform_in_errors() {
820        let r = reg();
821        let err = r
822            .plan("nearby BLE chat without accounts", Some("web"))
823            .unwrap_err();
824        let msg = err.to_string();
825        assert!(msg.contains("not `web` (resolved as `nextjs`)"), "{msg}");
826    }
827
828    #[test]
829    fn plan_infers_web_platform() {
830        let r = reg();
831        let plan = r
832            .plan("community platform for the web with profiles", None)
833            .expect("plan succeeds");
834        assert_eq!(plan.platform, "nextjs");
835    }
836
837    #[test]
838    fn template_files_load_for_all_templates() {
839        let r = reg();
840        for t in r.templates() {
841            let files = r.template_files(&t.name).expect("template files load");
842            assert!(!files.is_empty(), "template `{}` has no files", t.name);
843        }
844    }
845
846    #[test]
847    fn example_app_templates_embed_shared_packages() {
848        let r = reg();
849        for id in EXAMPLE_APP_TEMPLATE_IDS {
850            let t = r.template(id).expect(id);
851            assert!(t.example_app);
852            assert!(t.requires_mesh);
853            let files = r.template_files(id).expect("files");
854            assert!(
855                files
856                    .iter()
857                    .any(|(p, _)| p.to_string_lossy().contains("packages/mesh/src")),
858                "{id}: mesh sources"
859            );
860        }
861    }
862
863    #[test]
864    fn llms_txt_mentions_every_skill() {
865        let r = reg();
866        let txt = llms::llms_txt(&r);
867        for s in r.skills() {
868            assert!(txt.contains(&s.name), "llms.txt missing skill {}", s.name);
869        }
870    }
871
872    #[test]
873    fn capabilities_aggregate_packages_and_workflows() {
874        let r = reg();
875        let caps = r.capabilities();
876        let mesh = caps
877            .iter()
878            .find(|c| c.name == "mesh-networking")
879            .expect("mesh-networking capability exists");
880        assert!(mesh
881            .packages
882            .contains(&"@offline-protocol/mesh-sdk".to_string()));
883        assert!(!mesh.workflows.is_empty());
884    }
885}