1pub 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
32pub const CLI_NPM_PACKAGE: &str = "@offline-protocol/cli";
34
35pub const CLI_VERSION: &str = env!("CARGO_PKG_VERSION");
37
38pub 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
52pub 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 ("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 ("http", &["http-front"]),
178 ("curl", &["http-front"]),
179 ("docker", &["http-front"]),
180 ("offline-protocol-verify", &["local-api"]),
181 ("flutter", &["native-mobile"]),
183 ("dart", &["native-mobile"]),
184 ("java", &["server-runtime"]),
185 ("jvm", &["server-runtime"]),
186 ("cgo", &["server-runtime"]),
187 ("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 ("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 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 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 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 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 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 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 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 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 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 (
457 "A Ruby service that relays messages",
458 "offline_protocol gem",
459 ),
460 ("A Flutter app for nearby chat", "MeshSdk"),
461 (
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 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 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 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 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}