1use super::super::types::*;
4use super::types::KnowledgeGraph;
5
6impl KnowledgeGraph {
7 pub(crate) fn register_sovereign_stack(&mut self) {
9 self.register_trueno();
11 self.register_trueno_db();
12 self.register_trueno_graph();
13 self.register_trueno_viz();
14 self.register_trueno_rag();
15 self.register_trueno_zram();
16 self.register_trueno_ublk();
17 self.register_pepita();
18
19 self.register_aprender();
21
22 self.register_entrenar();
24 self.register_realizar();
25 self.register_whisper_apr();
26
27 self.register_depyler();
29 self.register_decy();
30 self.register_bashrs();
31 self.register_ruchy();
32
33 self.register_batuta();
35 self.register_repartir();
36 self.register_pforge();
37 self.register_forjar();
38
39 self.register_certeza();
41 self.register_pmat();
42 self.register_renacer();
43 self.register_apr_qa();
44 self.register_provable_contracts();
45 self.register_tiny_model_ground_truth();
46
47 self.register_alimentar();
49 self.register_pacha();
50
51 self.register_rmedia();
53
54 self.register_simular();
56 self.register_probar();
57 }
58
59 fn register_trueno(&mut self) {
60 let component = StackComponent::new(
61 "trueno",
62 "0.11.0",
63 StackLayer::Primitives,
64 "SIMD-accelerated tensor operations with GPU support and LZ4 compression",
65 )
66 .with_capabilities(vec![
67 Capability::new("vector_ops", CapabilityCategory::Compute)
68 .with_description("SIMD-accelerated vector operations"),
69 Capability::new("matrix_ops", CapabilityCategory::Compute)
70 .with_description("High-performance matrix multiplication"),
71 Capability::new("simd", CapabilityCategory::Compute)
72 .with_description("SIMD auto-vectorization (AVX2/AVX-512/NEON)"),
73 Capability::new("gpu", CapabilityCategory::Compute)
74 .with_description("GPU acceleration via wgpu (fixed PTX codegen)"),
75 Capability::new("lz4_compression", CapabilityCategory::Compute)
76 .with_description("LZ4 tensor compression for memory efficiency"),
77 ]);
78 self.register_component(component);
79 }
80
81 fn register_trueno_db(&mut self) {
82 let component = StackComponent::new(
83 "trueno-db",
84 "0.3.3",
85 StackLayer::Primitives,
86 "GPU-first embedded analytics database with SIMD fallback",
87 )
88 .with_capabilities(vec![
89 Capability::new("vector_store", CapabilityCategory::Storage)
90 .with_description("Efficient vector storage"),
91 Capability::new("similarity_search", CapabilityCategory::Storage)
92 .with_description("Fast similarity search with HNSW"),
93 Capability::new("persistence", CapabilityCategory::Storage)
94 .with_description("Durable data persistence"),
95 Capability::new("knn_search", CapabilityCategory::Storage)
96 .with_description("K-nearest neighbor queries"),
97 ]);
98 self.register_component(component);
99 }
100
101 fn register_trueno_graph(&mut self) {
102 let component = StackComponent::new(
103 "trueno-graph",
104 "0.1.1",
105 StackLayer::Primitives,
106 "GPU-first embedded graph database for code analysis",
107 )
108 .with_capabilities(vec![
109 Capability::new("pathfinding", CapabilityCategory::Compute)
110 .with_description("Dijkstra and A* pathfinding"),
111 Capability::new("centrality", CapabilityCategory::Compute)
112 .with_description("PageRank and betweenness centrality"),
113 Capability::new("community_detection", CapabilityCategory::Compute)
114 .with_description("Label propagation clustering"),
115 ]);
116 self.register_component(component);
117 }
118
119 fn register_trueno_viz(&mut self) {
120 let component = StackComponent::new(
121 "trueno-viz",
122 "0.1.1",
123 StackLayer::Primitives,
124 "SIMD/GPU/WASM-accelerated visualization",
125 )
126 .with_capabilities(vec![Capability::new(
127 "visualization",
128 CapabilityCategory::Compute,
129 )
130 .with_description("High-performance data visualization")]);
131 self.register_component(component);
132 }
133
134 fn register_trueno_rag(&mut self) {
135 let component = StackComponent::new(
136 "trueno-rag",
137 "0.1.0",
138 StackLayer::Primitives,
139 "RAG pipeline with chunking, retrieval, and reranking",
140 )
141 .with_capabilities(vec![
142 Capability::new("chunking", CapabilityCategory::Storage)
143 .with_description("Text chunking strategies (fixed, semantic, recursive)"),
144 Capability::new("dense_retrieval", CapabilityCategory::Storage)
145 .with_description("Vector similarity search via trueno-db"),
146 Capability::new("sparse_retrieval", CapabilityCategory::Storage)
147 .with_description("BM25 keyword search"),
148 Capability::new("hybrid_retrieval", CapabilityCategory::Storage)
149 .with_description("Combined dense + sparse retrieval"),
150 Capability::new("reranking", CapabilityCategory::MachineLearning)
151 .with_description("Cross-encoder reranking"),
152 Capability::new("context_assembly", CapabilityCategory::MachineLearning)
153 .with_description("Context window packing and citation tracking"),
154 ]);
155 self.register_component(component);
156 }
157
158 fn register_trueno_zram(&mut self) {
159 let component = StackComponent::new(
160 "trueno-zram",
161 "0.1.0",
162 StackLayer::Primitives,
163 "SIMD-accelerated memory compression for Linux zram",
164 )
165 .with_capabilities(vec![
166 Capability::new("lz4_compression", CapabilityCategory::Compute)
167 .with_description("SIMD-accelerated LZ4 compression (≥3 GB/s)"),
168 Capability::new("zstd_compression", CapabilityCategory::Compute)
169 .with_description("Zstandard compression with configurable levels"),
170 Capability::new("adaptive_compression", CapabilityCategory::Compute)
171 .with_description("Entropy-based algorithm selection"),
172 Capability::new("page_compression", CapabilityCategory::Compute)
173 .with_description("4KB page-aligned memory compression"),
174 Capability::new("simd_dispatch", CapabilityCategory::Compute)
175 .with_description("Runtime SIMD backend selection (AVX2/AVX-512/NEON)"),
176 ]);
177 self.register_component(component);
178 }
179
180 fn register_trueno_ublk(&mut self) {
181 let component = StackComponent::new(
182 "trueno-ublk",
183 "0.1.0",
184 StackLayer::Primitives,
185 "GPU-accelerated ZRAM block device replacement via userspace block driver (ublk)",
186 )
187 .with_capabilities(vec![
188 Capability::new("ublk_driver", CapabilityCategory::Compute)
189 .with_description("Userspace block device driver via libublk"),
190 Capability::new("gpu_compression", CapabilityCategory::Compute)
191 .with_description("GPU-accelerated page compression (CUDA/wgpu)"),
192 Capability::new("zram_replacement", CapabilityCategory::Storage)
193 .with_description("Drop-in Linux ZRAM replacement with GPU offload"),
194 Capability::new("adaptive_backend", CapabilityCategory::Compute)
195 .with_description("Automatic GPU/SIMD/CPU backend selection"),
196 Capability::new("io_uring", CapabilityCategory::Compute)
197 .with_description("High-performance I/O via io_uring"),
198 ]);
199 self.register_component(component);
200 }
201
202 fn register_pepita(&mut self) {
203 let component = StackComponent::new(
204 "pepita",
205 "0.1.0",
206 StackLayer::Primitives,
207 "Pure Rust kernel interfaces and distributed computing primitives for Sovereign AI",
208 )
209 .with_capabilities(vec![
210 Capability::new("io_uring", CapabilityCategory::Compute)
211 .with_description("Linux async I/O interface"),
212 Capability::new("ublk", CapabilityCategory::Compute)
213 .with_description("Userspace block device driver"),
214 Capability::new("blk_mq", CapabilityCategory::Compute)
215 .with_description("Multi-queue block layer"),
216 Capability::new("zram", CapabilityCategory::Storage)
217 .with_description("Compressed RAM storage with LZ4"),
218 Capability::new("vmm", CapabilityCategory::Distribution)
219 .with_description("KVM-based MicroVM runtime"),
220 Capability::new("virtio", CapabilityCategory::Distribution)
221 .with_description("Virtio vsock and block devices"),
222 Capability::new("simd", CapabilityCategory::Compute)
223 .with_description("SIMD operations (AVX-512/AVX2/SSE/NEON)"),
224 Capability::new("gpu", CapabilityCategory::Compute)
225 .with_description("GPU compute via wgpu"),
226 Capability::new("work_stealing", CapabilityCategory::Distribution)
227 .with_description("Blumofe-Leiserson work-stealing scheduler"),
228 ]);
229 self.register_component(component);
230 }
231
232 fn register_aprender(&mut self) {
233 let component = StackComponent::new(
234 "aprender",
235 "0.21.0",
236 StackLayer::MlAlgorithms,
237 "Next-generation machine learning library with APR v2 format (LZ4/ZSTD compression)",
238 )
239 .with_capabilities(vec![
240 Capability::new("apr_v2", CapabilityCategory::Storage)
241 .with_description("APR v2 format with binary index, LZ4/ZSTD compression"),
242 Capability::new("int4_quantization", CapabilityCategory::MachineLearning)
243 .with_description("Int4 model quantization"),
244 Capability::new("int8_quantization", CapabilityCategory::MachineLearning)
245 .with_description("Int8 model quantization"),
246 Capability::new("zero_copy_loading", CapabilityCategory::Storage)
247 .with_description("Zero-copy model loading via mmap"),
248 Capability::new("linear_regression", CapabilityCategory::MachineLearning),
249 Capability::new("logistic_regression", CapabilityCategory::MachineLearning),
250 Capability::new("decision_tree", CapabilityCategory::MachineLearning),
251 Capability::new("random_forest", CapabilityCategory::MachineLearning),
252 Capability::new("gbm", CapabilityCategory::MachineLearning)
253 .with_description("Gradient boosting machines"),
254 Capability::new("naive_bayes", CapabilityCategory::MachineLearning),
255 Capability::new("knn", CapabilityCategory::MachineLearning)
256 .with_description("K-nearest neighbors"),
257 Capability::new("svm", CapabilityCategory::MachineLearning)
258 .with_description("Support vector machines"),
259 Capability::new("kmeans", CapabilityCategory::MachineLearning),
260 Capability::new("pca", CapabilityCategory::MachineLearning)
261 .with_description("Principal component analysis"),
262 Capability::new("dbscan", CapabilityCategory::MachineLearning),
263 Capability::new("hierarchical", CapabilityCategory::MachineLearning),
264 Capability::new("standard_scaler", CapabilityCategory::MachineLearning),
265 Capability::new("minmax_scaler", CapabilityCategory::MachineLearning),
266 Capability::new("label_encoder", CapabilityCategory::MachineLearning),
267 Capability::new("train_test_split", CapabilityCategory::MachineLearning),
268 Capability::new("cross_validate", CapabilityCategory::MachineLearning),
269 Capability::new("grid_search", CapabilityCategory::MachineLearning),
270 ]);
271 self.register_component(component);
272 }
273
274 fn register_entrenar(&mut self) {
275 let component = StackComponent::new(
276 "entrenar",
277 "0.2.1",
278 StackLayer::MlPipeline,
279 "Training library with autograd, LoRA, and quantization",
280 )
281 .with_capabilities(vec![
282 Capability::new("autograd", CapabilityCategory::MachineLearning)
283 .with_description("Automatic differentiation"),
284 Capability::new("lora", CapabilityCategory::MachineLearning)
285 .with_description("Low-rank adaptation"),
286 Capability::new("qlora", CapabilityCategory::MachineLearning)
287 .with_description("Quantized LoRA"),
288 Capability::new("quantization", CapabilityCategory::MachineLearning)
289 .with_description("Model quantization (int8, int4)"),
290 Capability::new("model_merge", CapabilityCategory::MachineLearning),
291 Capability::new("distillation", CapabilityCategory::MachineLearning),
292 ]);
293 self.register_component(component);
294 }
295
296 fn register_realizar(&mut self) {
297 let component = StackComponent::new(
298 "realizar",
299 "0.4.0",
300 StackLayer::MlPipeline,
301 "Pure Rust ML inference engine with APR v2, GPU kernels (FlashAttention, Q4K/Q5K/Q6K)",
302 )
303 .with_capabilities(vec![
304 Capability::new("gguf", CapabilityCategory::MachineLearning)
305 .with_description("GGUF model format support"),
306 Capability::new("safetensors", CapabilityCategory::MachineLearning)
307 .with_description("Safetensors model loading"),
308 Capability::new("apr_v2_format", CapabilityCategory::MachineLearning)
309 .with_description("APR v2 model format with compression"),
310 Capability::new("gemm_kernel", CapabilityCategory::Compute)
311 .with_description("GPU matrix multiplication (naive, tiled, tensor core)"),
312 Capability::new("attention_kernel", CapabilityCategory::Compute)
313 .with_description("FlashAttention-style tiled attention"),
314 Capability::new("softmax_kernel", CapabilityCategory::Compute)
315 .with_description("Numerically stable softmax with warp shuffle"),
316 Capability::new("layernorm_kernel", CapabilityCategory::Compute)
317 .with_description("Fused layer normalization"),
318 Capability::new("quantize_kernel", CapabilityCategory::Compute)
319 .with_description("Q4_K/Q5_K/Q6_K dequantization fused with matmul"),
320 Capability::new("transformer_serving", CapabilityCategory::MachineLearning)
321 .with_description("LLM/transformer inference runtime"),
322 Capability::new("kv_cache", CapabilityCategory::MachineLearning)
323 .with_description("KV-cache for efficient generation"),
324 Capability::new("continuous_batching", CapabilityCategory::MachineLearning)
325 .with_description("Dynamic request batching"),
326 Capability::new("model_serving", CapabilityCategory::MachineLearning)
327 .with_description("Production model serving"),
328 Capability::new("moe_routing", CapabilityCategory::MachineLearning)
329 .with_description("Mixture-of-experts routing"),
330 Capability::new("circuit_breaker", CapabilityCategory::MachineLearning)
331 .with_description("Fault tolerance"),
332 Capability::new("lambda", CapabilityCategory::Distribution)
333 .with_description("AWS Lambda (53,000x faster cold start)"),
334 Capability::new("container", CapabilityCategory::Distribution)
335 .with_description("Container deployment"),
336 Capability::new("edge", CapabilityCategory::Distribution)
337 .with_description("Edge deployment"),
338 ]);
339 self.register_component(component);
340 }
341
342 fn register_whisper_apr(&mut self) {
343 let component = StackComponent::new(
344 "whisper-apr",
345 "0.1.0",
346 StackLayer::MlPipeline,
347 "Pure Rust OpenAI Whisper ASR - WASM-first, Int4/Int8 quantization, streaming",
348 )
349 .with_capabilities(vec![
350 Capability::new("speech_recognition", CapabilityCategory::MachineLearning)
351 .with_description("Automatic speech recognition (Whisper architecture)"),
352 Capability::new("streaming_transcription", CapabilityCategory::MachineLearning)
353 .with_description("Real-time streaming transcription"),
354 Capability::new("multilingual", CapabilityCategory::MachineLearning)
355 .with_description("99+ language support"),
356 Capability::new("apr_v2_whisper", CapabilityCategory::MachineLearning)
357 .with_description("APR v2 format with LZ4/ZSTD compression"),
358 Capability::new("whisper_quantization", CapabilityCategory::MachineLearning)
359 .with_description("Int4/Int8 quantized Whisper models"),
360 Capability::new("wasm_first", CapabilityCategory::Distribution)
361 .with_description("WASM-first design for browser deployment"),
362 Capability::new("no_std", CapabilityCategory::Distribution)
363 .with_description("no_std compatible for embedded"),
364 ]);
365 self.register_component(component);
366 }
367
368 fn register_depyler(&mut self) {
369 let component = StackComponent::new(
370 "depyler",
371 "0.1.0",
372 StackLayer::Transpilers,
373 "Python to Rust transpiler with ML oracle",
374 )
375 .with_capabilities(vec![
376 Capability::new("type_inference", CapabilityCategory::Transpilation)
377 .with_description("Python type inference"),
378 Capability::new("sklearn_to_aprender", CapabilityCategory::Transpilation)
379 .with_description("sklearn to aprender conversion"),
380 Capability::new("numpy_to_trueno", CapabilityCategory::Transpilation)
381 .with_description("NumPy to trueno conversion"),
382 ]);
383 self.register_component(component);
384 }
385
386 fn register_decy(&mut self) {
387 let component = StackComponent::new(
388 "decy",
389 "0.1.0",
390 StackLayer::Transpilers,
391 "C/C++ to Rust transpiler",
392 )
393 .with_capabilities(vec![
394 Capability::new("ownership_inference", CapabilityCategory::Transpilation)
395 .with_description("Infer Rust ownership from C code"),
396 Capability::new("unsafe_elimination", CapabilityCategory::Transpilation)
397 .with_description("Eliminate unsafe blocks where possible"),
398 ]);
399 self.register_component(component);
400 }
401
402 fn register_bashrs(&mut self) {
403 let component = StackComponent::new(
404 "bashrs",
405 "6.41.0",
406 StackLayer::Transpilers,
407 "Rust-to-Shell transpiler for deterministic bootstrap scripts",
408 )
409 .with_capabilities(vec![
410 Capability::new("rust_to_shell", CapabilityCategory::Transpilation)
411 .with_description("Transpile Rust to portable shell scripts"),
412 Capability::new("bootstrap_scripts", CapabilityCategory::Transpilation)
413 .with_description("Generate deterministic bootstrap scripts"),
414 Capability::new("cross_platform_shell", CapabilityCategory::Transpilation)
415 .with_description("Generate POSIX-compliant shell code"),
416 ]);
417 self.register_component(component);
418 }
419
420 fn register_ruchy(&mut self) {
421 let component = StackComponent::new(
422 "ruchy",
423 "3.213.0",
424 StackLayer::Transpilers,
425 "Systems scripting language that transpiles to idiomatic Rust",
426 )
427 .with_capabilities(vec![
428 Capability::new("script_to_rust", CapabilityCategory::Transpilation)
429 .with_description("Transpile scripts to idiomatic Rust"),
430 Capability::new("shell_semantics", CapabilityCategory::Transpilation)
431 .with_description("Shell-like semantics with Rust safety"),
432 Capability::new("wasm_target", CapabilityCategory::Transpilation)
433 .with_description("Compile to WebAssembly"),
434 Capability::new("extreme_tdd", CapabilityCategory::Validation)
435 .with_description("Built-in extreme TDD methodology"),
436 ]);
437 self.register_component(component);
438 }
439
440 fn register_batuta(&mut self) {
441 let component = StackComponent::new(
442 "batuta",
443 "0.1.0",
444 StackLayer::Orchestration,
445 "Workflow orchestrator for transpilation pipelines",
446 )
447 .with_capabilities(vec![
448 Capability::new("analysis", CapabilityCategory::Validation),
449 Capability::new("transpilation", CapabilityCategory::Transpilation),
450 Capability::new("optimization", CapabilityCategory::Compute),
451 Capability::new("validation", CapabilityCategory::Validation),
452 Capability::new("deployment", CapabilityCategory::Distribution),
453 ]);
454 self.register_component(component);
455 }
456
457 fn register_repartir(&mut self) {
458 let component = StackComponent::new(
459 "repartir",
460 "2.0.0",
461 StackLayer::Orchestration,
462 "Sovereign AI-grade distributed computing primitives (CPU, GPU, HPC, pepita integration)",
463 )
464 .with_capabilities(vec![
465 Capability::new("cpu_executor", CapabilityCategory::Distribution)
466 .with_description("Multi-core CPU execution with work-stealing"),
467 Capability::new("gpu_executor", CapabilityCategory::Distribution)
468 .with_description("wgpu GPU compute (Vulkan/Metal/DX12/WebGPU)"),
469 Capability::new("remote_executor", CapabilityCategory::Distribution)
470 .with_description("TCP-based distributed execution across machines"),
471 Capability::new("remote_tls", CapabilityCategory::Distribution)
472 .with_description("TLS-secured remote execution"),
473 Capability::new("work_stealing", CapabilityCategory::Distribution)
474 .with_description("Blumofe & Leiserson work-stealing scheduler"),
475 Capability::new("task_pool", CapabilityCategory::Distribution)
476 .with_description("High-level Pool API for task submission"),
477 Capability::new("tensor_ops", CapabilityCategory::Compute)
478 .with_description("trueno SIMD tensor integration"),
479 Capability::new("checkpoint", CapabilityCategory::Storage)
480 .with_description("trueno-db + Parquet state persistence"),
481 Capability::new("job_flow_tui", CapabilityCategory::Profiling)
482 .with_description("TUI dashboard for job monitoring"),
483 ]);
484 self.register_component(component);
485 }
486
487 fn register_certeza(&mut self) {
488 let component = StackComponent::new(
489 "certeza",
490 "0.1.0",
491 StackLayer::Quality,
492 "Quality validation framework",
493 )
494 .with_capabilities(vec![
495 Capability::new("coverage_check", CapabilityCategory::Validation),
496 Capability::new("mutation_testing", CapabilityCategory::Validation),
497 Capability::new("tdg_scoring", CapabilityCategory::Validation)
498 .with_description("Technical debt gauge scoring"),
499 Capability::new("privacy_audit", CapabilityCategory::Validation),
500 ]);
501 self.register_component(component);
502 }
503
504 fn register_pmat(&mut self) {
505 let component = StackComponent::new(
506 "pmat",
507 "2.205.0",
508 StackLayer::Quality,
509 "Zero-config AI context generation and code quality toolkit",
510 )
511 .with_capabilities(vec![
512 Capability::new("complexity_analysis", CapabilityCategory::Validation)
513 .with_description("Cyclomatic and cognitive complexity analysis"),
514 Capability::new("satd_detection", CapabilityCategory::Validation)
515 .with_description("Self-admitted technical debt detection"),
516 Capability::new("quality_gates", CapabilityCategory::Validation)
517 .with_description("Tiered quality enforcement"),
518 Capability::new("repo_health", CapabilityCategory::Validation)
519 .with_description("Repository health scoring (0-125)"),
520 Capability::new("mcp_server", CapabilityCategory::Distribution)
521 .with_description("MCP protocol server for AI agents"),
522 Capability::new("multi_language", CapabilityCategory::Validation)
523 .with_description("17+ programming language support"),
524 ]);
525 self.register_component(component);
526 }
527
528 fn register_pforge(&mut self) {
529 let component = StackComponent::new(
530 "pforge",
531 "0.1.4",
532 StackLayer::Orchestration,
533 "Zero-boilerplate MCP server framework with rust-mcp-sdk",
534 )
535 .with_capabilities(vec![
536 Capability::new("mcp_codegen", CapabilityCategory::Transpilation)
537 .with_description("Declarative MCP server code generation"),
538 Capability::new("mcp_runtime", CapabilityCategory::Distribution)
539 .with_description("MCP protocol runtime via rust-mcp-sdk"),
540 Capability::new("zero_boilerplate", CapabilityCategory::Transpilation)
541 .with_description("Macro-based boilerplate elimination"),
542 Capability::new("tool_orchestration", CapabilityCategory::Distribution)
543 .with_description("AI agent tool-use orchestration"),
544 Capability::new("resource_provider", CapabilityCategory::Distribution)
545 .with_description("MCP resource exposure for agents"),
546 Capability::new("prompt_templates", CapabilityCategory::Distribution)
547 .with_description("Reusable prompt template serving"),
548 Capability::new("extreme_tdd", CapabilityCategory::Validation)
549 .with_description("Built-in extreme TDD methodology"),
550 ]);
551 self.register_component(component);
552 }
553
554 fn register_renacer(&mut self) {
555 let component = StackComponent::new(
556 "renacer",
557 "0.7.0",
558 StackLayer::Quality,
559 "Pure Rust system call tracer with source-aware correlation",
560 )
561 .with_capabilities(vec![
562 Capability::new("syscall_trace", CapabilityCategory::Profiling)
563 .with_description("System call tracing"),
564 Capability::new("flamegraph", CapabilityCategory::Profiling)
565 .with_description("Flamegraph generation"),
566 Capability::new("golden_trace_comparison", CapabilityCategory::Profiling)
567 .with_description("Compare traces for semantic equivalence"),
568 ]);
569 self.register_component(component);
570 }
571
572 fn register_alimentar(&mut self) {
573 let component = StackComponent::new(
574 "alimentar",
575 "0.1.0",
576 StackLayer::Data,
577 "Data loading and preprocessing in pure Rust",
578 )
579 .with_capabilities(vec![
580 Capability::new("csv", CapabilityCategory::Storage),
581 Capability::new("parquet", CapabilityCategory::Storage),
582 Capability::new("json", CapabilityCategory::Storage),
583 Capability::new("streaming", CapabilityCategory::Storage)
584 .with_description("Streaming data loading"),
585 ]);
586 self.register_component(component);
587 }
588
589 fn register_pacha(&mut self) {
590 let component = StackComponent::new(
591 "pacha",
592 "0.1.0",
593 StackLayer::Data,
594 "Model, Data and Recipe Registry for MLOps",
595 )
596 .with_capabilities(vec![
597 Capability::new("model_versioning", CapabilityCategory::Storage)
598 .with_description("Semantic versioned model artifacts"),
599 Capability::new("model_lineage", CapabilityCategory::Storage)
600 .with_description("Model lineage tracking"),
601 Capability::new("artifact_storage", CapabilityCategory::Storage)
602 .with_description("Artifact storage and retrieval"),
603 Capability::new("dataset_versioning", CapabilityCategory::Storage)
604 .with_description("Dataset version control"),
605 Capability::new("data_lineage", CapabilityCategory::Storage)
606 .with_description("Data lineage and provenance"),
607 Capability::new("recipe_management", CapabilityCategory::Storage)
608 .with_description("Training recipe versioning"),
609 Capability::new("experiment_tracking", CapabilityCategory::Validation)
610 .with_description("Experiment metrics and comparison"),
611 ]);
612 self.register_component(component);
613 }
614
615 fn register_simular(&mut self) {
616 let component = StackComponent::new(
617 "simular",
618 "0.2.0",
619 StackLayer::MlPipeline,
620 "Unified simulation engine with Zero-JS WASM architecture and TUI",
621 )
622 .with_capabilities(vec![
623 Capability::new("physics_simulation", CapabilityCategory::Compute)
624 .with_description("N-body orbital mechanics with symplectic integrators"),
625 Capability::new("monte_carlo", CapabilityCategory::Compute)
626 .with_description("Monte Carlo Pi, Kingman's formula simulations"),
627 Capability::new("optimization", CapabilityCategory::Compute)
628 .with_description("TSP GRASP with 2-opt local search"),
629 Capability::new("discrete_event", CapabilityCategory::Compute)
630 .with_description("Queue theory, Little's Law simulations"),
631 Capability::new("zero_js_wasm", CapabilityCategory::Compute)
632 .with_description("Pure Rust/WASM with single-line JS initialization"),
633 Capability::new("wasm_canvas", CapabilityCategory::Compute)
634 .with_description("Canvas 2D rendering via web-sys"),
635 Capability::new("wasm_dom", CapabilityCategory::Compute)
636 .with_description("DOM manipulation via web-sys"),
637 Capability::new("edd_demos", CapabilityCategory::Validation)
638 .with_description("Equation-Driven Development demonstration framework"),
639 Capability::new("jidoka_guards", CapabilityCategory::Validation)
640 .with_description("Toyota Way stop-on-error invariant checking"),
641 Capability::new("poka_yoke", CapabilityCategory::Validation)
642 .with_description("Type-safe units via uom crate"),
643 Capability::new("tui_ratatui", CapabilityCategory::Compute)
644 .with_description("Terminal UI with ratatui"),
645 Capability::new("deterministic_replay", CapabilityCategory::Validation)
646 .with_description("Reproducible simulations with PCG seeds"),
647 ]);
648 self.register_component(component);
649 }
650
651 fn register_probar(&mut self) {
652 let component = StackComponent::new(
653 "probar",
654 "0.1.0",
655 StackLayer::Quality,
656 "Property-based testing and GUI/pixel coverage for WASM demos",
657 )
658 .with_capabilities(vec![
659 Capability::new("pixel_coverage", CapabilityCategory::Validation)
660 .with_description("Canvas pixel coverage analysis"),
661 Capability::new("gui_coverage", CapabilityCategory::Validation)
662 .with_description("Interactive element coverage tracking"),
663 Capability::new("property_testing", CapabilityCategory::Validation)
664 .with_description("Property-based test generation"),
665 Capability::new("metamorphic_testing", CapabilityCategory::Validation)
666 .with_description("Metamorphic relation validation"),
667 Capability::new("invariant_checking", CapabilityCategory::Validation)
668 .with_description("Runtime invariant assertion"),
669 ]);
670 self.register_component(component);
671 }
672
673 fn register_forjar(&mut self) {
674 let component = StackComponent::new(
675 "forjar",
676 "0.1.0",
677 StackLayer::Orchestration,
678 "Rust-native IaC for bare-metal provisioning with BLAKE3 content-addressed state",
679 )
680 .with_capabilities(vec![
681 Capability::new("iac_provisioning", CapabilityCategory::Distribution)
682 .with_description("Bare-metal infrastructure provisioning via SSH"),
683 Capability::new("blake3_state", CapabilityCategory::Validation)
684 .with_description("BLAKE3 content-addressed drift detection"),
685 Capability::new("idempotent_apply", CapabilityCategory::Validation)
686 .with_description("Idempotent convergence with hash-based skip"),
687 Capability::new("template_resolution", CapabilityCategory::Transpilation)
688 .with_description("{{params.X}} and {{machine.Y.Z}} template engine"),
689 Capability::new("recipe_system", CapabilityCategory::Distribution)
690 .with_description("Nix-inspired composable configuration recipes"),
691 Capability::new("topo_sort", CapabilityCategory::Compute)
692 .with_description("DAG-based resource dependency ordering"),
693 ]);
694 self.register_component(component);
695 }
696
697 fn register_apr_qa(&mut self) {
698 let component = StackComponent::new(
699 "apr-qa",
700 "0.1.0",
701 StackLayer::Quality,
702 "APR model QA playbook with test generation, execution, and reporting",
703 )
704 .with_capabilities(vec![
705 Capability::new("qa_test_generation", CapabilityCategory::Validation)
706 .with_description("Generate QA tests for APR models"),
707 Capability::new("model_validation", CapabilityCategory::Validation)
708 .with_description("Validate APR model correctness and integrity"),
709 Capability::new("qa_runner", CapabilityCategory::Validation)
710 .with_description("Execute QA test suites against APR models"),
711 Capability::new("benchmark_runner", CapabilityCategory::Profiling)
712 .with_description("Run performance benchmarks on APR models"),
713 Capability::new("qa_report", CapabilityCategory::Validation)
714 .with_description("Generate QA reports with metrics and recommendations"),
715 Capability::new("coverage_report", CapabilityCategory::Validation)
716 .with_description("Model coverage analysis and reporting"),
717 ]);
718 self.register_component(component);
719 }
720
721 fn register_provable_contracts(&mut self) {
722 let component = StackComponent::new(
723 "provable-contracts",
724 "0.1.0",
725 StackLayer::Quality,
726 "YAML contract to Kani verification pipeline for ML kernel correctness",
727 )
728 .with_capabilities(vec![
729 Capability::new("contract_parsing", CapabilityCategory::Validation)
730 .with_description("Parse YAML contract specifications for ML kernels"),
731 Capability::new("scaffold_generation", CapabilityCategory::Transpilation)
732 .with_description("Generate Kani harness scaffolds from contracts"),
733 Capability::new("kani_verification", CapabilityCategory::Validation)
734 .with_description("Formal verification via Kani model checker"),
735 Capability::new("probar_generation", CapabilityCategory::Validation)
736 .with_description("Generate probar property tests from contracts"),
737 Capability::new("traceability_audit", CapabilityCategory::Validation)
738 .with_description("Contract-to-proof traceability audit trail"),
739 Capability::new("binding_registry", CapabilityCategory::Validation)
740 .with_description("Registry of contract bindings to kernel implementations"),
741 ]);
742 self.register_component(component);
743 }
744
745 fn register_rmedia(&mut self) {
746 let component = StackComponent::new(
747 "rmedia",
748 "0.1.0",
749 StackLayer::Media,
750 "Pure Rust headless video editor — 7-crate workspace, MLT XML compatibility, 1.73x faster than melt",
751 )
752 .with_capabilities(vec![
753 Capability::new("video_rendering", CapabilityCategory::Media)
754 .with_description("Headless video rendering pipeline"),
755 Capability::new("mlt_xml", CapabilityCategory::Media)
756 .with_description("MLT XML timeline parsing and execution"),
757 Capability::new("ffmpeg_encode", CapabilityCategory::Media)
758 .with_description("FFmpeg-based encoding/decoding"),
759 Capability::new("transition_blend", CapabilityCategory::Media)
760 .with_description("Cross-dissolve, fade, and wipe transitions"),
761 Capability::new("course_production", CapabilityCategory::Media)
762 .with_description("End-to-end course video production pipeline"),
763 Capability::new("audio_processing", CapabilityCategory::Media)
764 .with_description("Audio mixing, normalization, and ducking"),
765 Capability::new("subtitle_burn_in", CapabilityCategory::Media)
766 .with_description("ASS/SRT subtitle burn-in rendering"),
767 Capability::new("media_concat", CapabilityCategory::Media)
768 .with_description("Frame-accurate media concatenation"),
769 Capability::new("transcription_qa", CapabilityCategory::Validation)
770 .with_description("Transcript quality scoring and validation"),
771 Capability::new("vocabulary_enrichment", CapabilityCategory::ContentGeneration)
772 .with_description("Key term extraction from transcripts"),
773 Capability::new("content_generation", CapabilityCategory::ContentGeneration)
774 .with_description("Outline, reflection prompt, and landing page generation"),
775 Capability::new("svg_asset_pipeline", CapabilityCategory::Media)
776 .with_description("SVG banner and thumbnail generation"),
777 Capability::new("course_quality_scoring", CapabilityCategory::Validation)
778 .with_description("Multi-dimensional course quality scoring"),
779 Capability::new("course_publishing", CapabilityCategory::Distribution)
780 .with_description("Coursera/platform publishing pipeline"),
781 ]);
782 self.register_component(component);
783 }
784
785 fn register_tiny_model_ground_truth(&mut self) {
786 let component = StackComponent::new(
787 "tiny-model-ground-truth",
788 "0.1.0",
789 StackLayer::Quality,
790 "Popperian falsification test suite for model conversion parity",
791 )
792 .with_capabilities(vec![
793 Capability::new("parity_checking", CapabilityCategory::Validation)
794 .with_description("Validate output parity between HuggingFace and realizar"),
795 Capability::new("oracle_generation", CapabilityCategory::Validation)
796 .with_description("Generate oracle outputs from HuggingFace reference models"),
797 Capability::new("falsification_testing", CapabilityCategory::Validation)
798 .with_description("Popperian falsification of conversion correctness"),
799 Capability::new("quantization_drift", CapabilityCategory::Validation)
800 .with_description("Measure quantization drift across format conversions"),
801 Capability::new("roundtrip_validation", CapabilityCategory::Validation)
802 .with_description("Validate roundtrip conversion fidelity"),
803 ]);
804 self.register_component(component);
805 }
806}