capability_crate_writer/

grower_crate_writer.rs

// ---------------- [ File: capability-crate-writer/src/grower_crate_writer.rs ]
crate::ix!();

error_tree!{
    pub enum GrowerModelWriteSkillTreeError {
        Default,
    }
}

pub trait SkillTreeCrateWriter {

    type Error;

    fn skill_tree_write_crate_text(&self) -> Result<String,Self::Error>;
}

impl SkillTreeCrateWriter for GrowerModel {
    type Error = GrowerModelWriteSkillTreeError;

    fn skill_tree_write_crate_text(&self) -> Result<String, Self::Error> {
        use std::collections::{HashMap, HashSet, VecDeque};

        info!("model = {:#?}", self);

        // -------------------------------------------------------------------------
        // Build a name‑to‑node map and discover *root* nodes (those that are never
        // referenced as a child).  We also record quick‑lookup helper sets.
        // -------------------------------------------------------------------------
        let all_nodes = self.core_string_skeleton().top_down_nodes();

        let mut node_map          = HashMap::<String, CoreSkeletalNode>::new();
        let mut referenced_childs = HashSet::<String>::new();
        let mut leaf_holder_names = HashSet::<String>::new();
        let mut dispatch_names    = HashSet::<String>::new();

        for n in all_nodes {
            match &n {
                CoreSkeletalNode::Dispatch(d) => {
                    dispatch_names.insert(d.name().clone());
                    referenced_childs.extend(d.children().iter().map(|c| c.name().clone()));
                }
                CoreSkeletalNode::Aggregate(a) => {
                    referenced_childs.extend(a.children().iter().map(|c| c.name().clone()));
                }
                CoreSkeletalNode::LeafHolder(lh) => {
                    leaf_holder_names.insert(lh.name().clone());
                }
            }
            node_map.insert(n.name().clone(), n);
        }

        let mut roots: Vec<String> = node_map
            .keys()
            .filter(|name| !referenced_childs.contains(*name))
            .cloned()
            .collect();
        roots.sort(); // deterministic root ordering
        trace!(?roots, "identified crate‑emission roots");

        // -------------------------------------------------------------------------
        // Crate preamble
        // -------------------------------------------------------------------------
        let mut crate_text = String::new();
        crate_text.push_str(
            r#"// SPDX-License-Identifier: GPL-3.0-only
// This crate was generated by `capability` (GPLv3 licensed).
// This generated crate is explicitly licensed under GPLv3.

#![allow(unused_imports)]
#![allow(unused_variables)]

use std::fmt::Debug;
use serde::{Serialize, Deserialize};
use std::hash::Hash;
use tracing::*;
use variant_builder_macro::*;
use rand_construct::*;
use ai_descriptor::*;
use derive_builder::*;
use getset::*;

"#,
        );

        let mut entrypoint_type = roots[0].to_string();

        let root_is_dispatch = matches!(
            node_map.get(&entrypoint_type),
            Some(CoreSkeletalNode::Dispatch(_))
        );

        let top_name = if root_is_dispatch {
            format!("{entrypoint_type}Top")
        } else {
            entrypoint_type.clone()
        };

        let top_snake = top_name.to_snake_case();
        let top_kebab = top_name.to_kebab_case();

    crate_text.push_str(&formatdoc!(r#"
#[cfg(test)]
mod {top_snake}_test_suite {{
    use super::*;
    use traced_test::*;
    use tracing_setup::*;

    #[traced_test]
    fn random_instantiation_test() {{
        type This = {top_name};
        let item = This::random();
        println!("------------------------[random-{top_kebab}]");
        (0..120).for_each(|_| println!("{{}}\n", This::random().ai()));
        //assert!(false); // uncomment this assertion to see the results
    }}
}}

"#));

        if root_is_dispatch {

            info!("installing dispatch abstraction layer to the top");

            let inner_field   = entrypoint_type.to_snake_case();   // `adaptive_brainwave_phase_locking`

            let child = node_map.get(&entrypoint_type).expect("child must exist when building variants");

            let header_text = match child {
                CoreSkeletalNode::Dispatch(dchild) => dchild.descriptor(),
                CoreSkeletalNode::Aggregate(a) => a.descriptor(),
                CoreSkeletalNode::LeafHolder(lh) => lh.descriptor(),
            };

            crate_text.push_str(&formatdoc! {r#"
                #[derive(VariantBuilder,Debug, Clone, ItemWithFeatures, RandConstruct, Hash, PartialEq, Eq)]
                pub enum {top_name} {{
                    #[default]
                    #[ai(wrap = "ItemWithFeatures")]
                    #[nested_builder]
                    #[ai(header_prefix="{header_text} ")]
                    {entrypoint_type}({entrypoint_type}),
                }}

                "#});

                // replace the “entry point” used in the test module
                crate_text = crate_text.replace(
                    &format!("type This = {entrypoint_type};"),
                    &format!("type This = {top_name};"),
                );
        }

        info!("about to emit nodes");

        // -------------------------------------------------------------------------
        // Utility: descriptor lookup for leaves
        // -------------------------------------------------------------------------
        fn leaf_descriptor_for(
            leaf_holder_name: &str,
            leaf_name:        &str,
            expansions:       &AnnotatedLeafHolderExpansions,
        ) -> String {
            for holder in expansions.annotated_leaf_holders() {
                if holder.leaf_holder_name() == leaf_holder_name {
                    for ann in holder.annotated_leaves() {
                        if ann.leaf_name() == leaf_name {
                            return ann.leaf_descriptor().to_string();
                        }
                    }
                }
            }
            format!("No descriptor found for leaf '{leaf_name}'.")
        }

        // -------------------------------------------------------------------------
        // Breadth‑first emission — preserves *parent‑variant order* at each level
        // -------------------------------------------------------------------------
        let mut emitted = HashSet::<String>::new();

        #[instrument(level = "trace", skip_all)]
        fn emit_node(
            name:               &str,
            node_map:           &HashMap<String, CoreSkeletalNode>,
            leaf_holder_names:  &HashSet<String>,
            dispatch_names:     &HashSet<String>,
            emitted:            &mut HashSet<String>,
            crate_text:         &mut String,
            model:              &GrowerModel,
        ) {
            if !emitted.insert(name.to_string()) {
                trace!(node = name, "already emitted — skipping");
                return;
            }

            let node = match node_map.get(name) {
                Some(n) => n,
                None => {
                    warn!(node = name, "child referenced but not found in map");
                    return;
                }
            };

            debug!("emit_node, passed preliminary checks");

            match node {
                // ------------------------------------------------------------------ DISPATCH
                CoreSkeletalNode::Dispatch(d) => {
                    let mut variants = String::new();

                    for (idx, ch) in d.children().iter().enumerate() {

                        let child = node_map.get(ch.name())
                            .expect("child must exist when building variants");

                        if idx == 0 {
                            variants.push_str("#[default]\n");
                        }

                        match child {
                            // ───── nested dispatch ────────────────────────────────
                            CoreSkeletalNode::Dispatch(dchild) => {
                                variants.push_str("    #[ai(wrap = \"ItemWithFeatures\")]\n");
                                variants.push_str("    #[nested_builder]\n");
                                variants.push_str(&format!(
                                        "    #[ai(header_prefix = \"{} \")]\n",
                                        dchild.descriptor()
                                ));
                            }
                            // ───── aggregate struct ───────────────────────────────
                            CoreSkeletalNode::Aggregate(_) => {
                                variants.push_str("    #[ai(wrap = \"ItemWithFeatures\")]\n");
                            }
                            // ───── leaf holder – simple feature list ──────────────
                            CoreSkeletalNode::LeafHolder(lh) => {
                                variants.push_str("    #[no_builder]\n");
                                variants.push_str(&format!(
                                        "    #[ai(\"{}\")]\n",
                                        lh.descriptor()
                                ));
                            }
                        }

                        // common line that actually declares the variant
                        variants.push_str(&format!("    {}({}),\n", ch.name(), ch.name()));
                    }

                    crate_text.push_str(&formatdoc!(
                        r#"
                        #[derive(VariantBuilder, Debug, Clone, ItemWithFeatures, RandConstruct, Hash, PartialEq, Eq)]
                        pub enum {ename} {{
                            {variants}
                        }}

                        "#,
                        ename    = d.name(),
                        variants = variants.trim_end(),
                    ));
                }

                // ---------------------------------------------------------------- AGGREGATE
                CoreSkeletalNode::Aggregate(a) => {
                    let mut fields = String::new();
                    let mut found_opt_child = false;

                    for ch in a.children() {

                        let field_name = ch.name().to_case(Case::Snake);

                        let child = node_map.get(ch.name())
                            .expect("child must exist when building variants");

                        let child_descriptor = match child {
                            CoreSkeletalNode::Dispatch(dchild) => dchild.descriptor(),
                            CoreSkeletalNode::Aggregate(a) => a.descriptor(),
                            CoreSkeletalNode::LeafHolder(lh) => lh.descriptor(),
                        };

                        if *ch.optional() {
                            let p = *ch.probability() as f64 / 100.0;

                            let opt_header = match found_opt_child {
                                true  => "No ",
                                false => "Specifically contains no ",
                            };

                            fields.push_str(&format!(
                                r#"
    #[ai(feature_if_none="{opt_header}'{child}' module.")]
    #[ai(feature_prefix_if_some="{child_descriptor} ")]
    #[rand_construct(psome={prob})]
    {field}: Option<{child}>,"#,
                                child = ch.name(),
                                prob  = p,
                                field = field_name,
                            ));

                            found_opt_child = true;

                        } else {
                            fields.push_str(&format!(
                                r#"
    #[ai("{child_descriptor}")]
    {field}: {child},"#,
                                child = ch.name(),
                                field = field_name,
                            ));

                        }
                    }

                    crate_text.push_str(&formatdoc!(
                        r#"
                        #[derive(Builder, Debug, Clone, ItemWithFeatures, RandConstruct, Default, Hash, PartialEq, Eq, Getters)]
                        #[builder(pattern="owned", setter(into))]
                        #[ai("{desc}")]
                        pub struct {sname} {{
                            {fields}
                        }}

                        "#,
                        desc   = a.descriptor(),
                        sname  = a.name(),
                        fields = fields.trim_end(),
                    ));
                }

                // -------------------------------------------------------------- LEAF‑HOLDER
                CoreSkeletalNode::LeafHolder(lh) => {
                    let mut variants = String::new();
                    for (idx, leaf) in lh.leaves().iter().enumerate() {
                        if idx == 0 {
                            variants.push_str("#[default]\n");
                        }
                        let ld = leaf_descriptor_for(
                            lh.name(),
                            leaf,
                            model.annotated_leaf_holder_expansions(),
                        );
                        variants.push_str(&format!(
                            "    #[ai(\"{ld}\")]\n    {leaf},\n",
                            ld   = ld,
                            leaf = leaf
                        ));
                    }

                    crate_text.push_str(&formatdoc!(
                        r#"
                        #[derive(Debug, Clone, ItemFeature, RandConstruct, Default, Hash, PartialEq, Eq)]
                        pub enum {ename} {{
                            {variants}
                        }}

                        "#,
                        ename    = lh.name(),
                        variants = variants.trim_end(),
                    ));
                }
            }
        }

        // -------------------------- breadth‑first traversal --------------------------
        let mut queue: VecDeque<String> = roots.into_iter().collect();
        while let Some(current) = queue.pop_front() {

            debug!("processing {:#?}", current);

            emit_node(
                &current,
                &node_map,
                &leaf_holder_names,
                &dispatch_names,
                &mut emitted,
                &mut crate_text,
                self,
            );

            debug!("emit_node terminated");

            if let Some(node) = node_map.get(&current) {
                match node {
                    CoreSkeletalNode::Dispatch(d) => {
                        debug!("processing Dispatch node {:#?}", d);
                        for ch in d.children() {
                            if !emitted.contains(ch.name()) {
                                queue.push_back(ch.name().clone());
                            }
                        }
                    }
                    CoreSkeletalNode::Aggregate(a) => {
                        debug!("processing Aggregate node {:#?}", a);
                        for ch in a.children() {
                            if !emitted.contains(ch.name()) {
                                queue.push_back(ch.name().clone());
                            }
                        }
                    }
                    CoreSkeletalNode::LeafHolder(lh) => {
                        debug!("processing LeafHolder node {:#?}", lh);
                    }
                }
            }
        }

        Ok(crate_text)
    }
}

#[cfg(test)]
mod grower_model_tests {
    use super::*;

    #[traced_test]
    async fn basic_smoke() -> Result<(),GrowerModelWriteSkillTreeError> {

        let mut map = HashMap::<&'static str, &[&'static str]>::default();

        map.insert("foxes", &[
            "fox-advanced-social-group-coordination-and-complex-cooperative-task-execution",
            "fox-performance-conditioning-for-speed-and-endurance",
            "fox-advanced-performance-design-and-precision-task-choreography-mastery",
            "fox-initial-directional-cue-response-training-to-basic-verbal-and-hand-gestures",
            "fox-basic-den-and-resting-area-familiarization-and-conditioning",
            "fox-basic-target-following-over-short-distances-and-simple-pathways",
            "fox-social-group-coordination-and-cooperative-task-conditioning",
            "fox-simple-habitat-maintenance-and-comfort-management-awareness",
            "fox-long-duration-station-holding-and-task-performance-under-significant-distractions",
            "fox-positive-food-reward-conditioning-with-precise-delivery-timing",
            "fox-performance-prop-interaction-techniques",
            "fox-soft-vocal-tone-and-human-voice-conditioning-for-trust-building",
            "fox-positive-reinforcement-training-techniques",
            "fox-object-manipulation-under-forest-conditions",
            "fox-advanced-object-manipulation-in-forest-settings",
            "fox-basic-station-area-familiarization-and-short-duration-conditioning",
            "fox-target-tracking-through-variable-terrain",
            "fox-positive-food-association-conditioning-with-human-interaction",
            "fox-basic-agility-and-precision-foot-placement-training-over-low-obstacles",
            "fox-social-performance-cue-responsiveness",
            "fox-station-duration-extension-up-to-3-minutes-under-controlled-distractions",
            "fox-stress-reduction-and-socialization-methods",
            "fox-highly-precise-target-following-and-navigation-through-challenging-and-variable-environments",
            "fox-controlled-introduction-to-minimal-environmental-distractions-and-stimuli",
            "fox-complex-directional-cue-response-with-combined-visual-verbal-and-tactile-signals",
            "fox-target-identification-and-tracking-skills",
            "fox-advanced-territorial-navigation-resource-management-and-boundary-recognition-training",
            "fox-intermediate-agility-course-navigation-with-complex-terrain-and-obstacles",
            "fox-agility-and-performance-cue-mastery",
            "fox-advanced-object-manipulation-tool-use-and-complex-task-performance-conditioning",
            "fox-station-duration-training-starting-from-15-to-45-seconds",
            "fox-simple-social-presence-conditioning-with-multiple-handlers-and-conspecifics",
            "fox-extended-target-following-and-navigation-over-complex-and-variable-terrain",
            "fox-gradual-human-presence-desensitization-through-controlled-proximity-management",
            "fox-adaptive-responsiveness-to-sophisticated-multi-modal-command-sequences",
            "fox-initial-observation-of-stress-and-relaxation-body-language-signals",
            "fox-simple-object-touch-retrieval-and-target-response-conditioning",
            "fox-controlled-conditioning-to-low-intensity-environmental-distractions",
            "fox-precision-object-manipulation-placement-and-sequential-task-training",
            "fox-comprehensive-emotional-and-stress-state-monitoring-for-optimal-engagement",
            "fox-agility-course-vertical-scaling",
            "fox-basic-grooming-health-inspection-and-handling-desensitization",
            "fox-responsiveness-conditioning-to-subtle-human-body-language-and-gesture-cues",
            "fox-positive-reward-frequency-and-type-optimization-for-task-complexity",
            "fox-initial-scent-familiarization-and-positive-object-association",
            "fox-comprehensive-problem-solving-adaptive-behavior-and-task-sequencing-conditioning",
            "fox-extended-grooming-handling-and-comprehensive-health-examination-conditioning",
            "fox-group-social-coordination-techniques",
            "fox-advanced-agility-course-precision-training",
            "fox-extended-performance-of-complex-sequential-behavioral-tasks-with-memory-retention",
            "fox-controlled-introduction-to-basic-hand-proximity-and-gentle-touch",
            "fox-basic-eye-contact-duration-awareness-and-conditioning",
            "fox-group-social-cue-training",
            "fox-agility-course-navigation-with-complex-obstacles",
            "fox-advanced-object-discrimination-training",
            "fox-targeted-enrichment-exercise-regimens",
            "fox-controlled-conditioning-to-moderate-environmental-and-social-distractions",
            "fox-social-hierarchy-performance-management",
        ]);

        map.insert("real-estate", &[
            "real-estate-72-hour-clause-contingent-sale-risk-management",
            "real-estate-abstract-of-title-verification-and-analysis",
            "real-estate-acceleration-clause-default-risk-management",
            "real-estate-accession-property-rights-clarification",
            "real-estate-acreage-measurement-and-land-valuation",
            "real-estate-ad-valorem-property-tax-management",
            "real-estate-adjustable-rate-mortgage-risk-mitigation",
            "real-estate-adjusted-basis-capital-gain-calculation",
            "real-estate-adverse-possession-property-rights-defense",
            "real-estate-affordable-housing-investment-and-social-impact-strategy",
            "real-estate-agency-transaction-representation-management",
            "real-estate-agent-transaction-facilitation-management",
            "real-estate-air-rights-acquisition-and-utilization",
            "real-estate-alluvion-and-accretion-property-boundary-management",
            "real-estate-american-land-title-association-compliance",
            "real-estate-amortizing-loan-management-and-strategy",
            "real-estate-anchor-store-commercial-investment-strategy",
            "real-estate-annexation-and-zoning-impact-management",
            "real-estate-annual-percentage-rate-cost-assessment",
            "real-estate-anti-money-laundering-compliance-and-risk-management",
            "real-estate-apartment-investment-analysis-and-management",
            "real-estate-appraisal-property-valuation-strategy",
            "real-estate-appraisal-standards-professional-compliance",
            "real-estate-appraised-value-assessment-and-validation",
            "real-estate-appurtenant-easement-rights-and-valuation",
            "real-estate-arms-length-transaction-principle-compliance",
            "real-estate-arrears-debt-collection-and-management",
            "real-estate-asking-price-negotiation-strategy",
            "real-estate-asset-identification-and-financial-resource-management",
            "real-estate-assignment-law-contractual-rights-transfer",
            "real-estate-assumption-of-mortgage-transaction-management",
            "real-estate-attorney-at-law-transaction-and-legal-protection",
            "real-estate-attorney-in-fact-financial-authority-management",
            "real-estate-avulsion-property-boundary-risk-management",
            "real-estate-balance-sheet-preparation-and-financial-reporting",
            "real-estate-balloon-mortgage-structure-and-risk-management",
            "real-estate-bargain-and-sale-deed-risk-clarification",
            "real-estate-benchmarking-investment-performance-management",
            "real-estate-beneficiary-rights-and-management",
            "real-estate-bequest-property-transfer-and-legacy-planning",
            "real-estate-bilateral-contract-management-and-enforcement",
            "real-estate-bill-of-sale-documentation-and-transfer-management",
            "real-estate-blanket-loan-portfolio-financing-strategy",
            "real-estate-blockchain-title-transfer-and-risk-management",
            "real-estate-boiler-insurance-coverage-and-risk-management",
            "real-estate-bona-fide-purchaser-rights-and-protection",
            "real-estate-book-value-calculation-and-valuation-management",
            "real-estate-boot-property-exchange-and-tax-management",
            "real-estate-boundary-determination-and-dispute-resolution",
            "real-estate-bpo-standards-and-guidelines-compliance",
            "real-estate-broker-transaction-integrity-management",
            "real-estate-brokerage-market-access-management",
            "real-estate-brokers-price-opinion-valuation-and-compliance",
            "real-estate-bubble-market-risk-awareness",
        ]);

        map.insert("zoosemiosis", &[
            "zoosemiotic-danger-safety-alarm-calls-and-predator-response-training",
            "zoosemiotic-danger-safety-context-driven-symbolic-learning-and-adaptation",
            "zoosemiotic-danger-safety-cross-species-threat-recognition-and-signaling",
            "zoosemiotic-danger-safety-minimal-ambiguity-and-rapid-sign-processing-training",
            "zoosemiotic-danger-safety-risk-assessment-and-group-vigilance-pattern-recognition",
            "zoosemiotic-family-social-bonds-cooperation-conflict-and-reconciliation-pattern-training",
            "zoosemiotic-family-social-bonds-minimal-symbolic-density-in-social-maintenance-signals",
            "zoosemiotic-family-social-bonds-parent-offspring-signaling-patterns",
            "zoosemiotic-family-social-bonds-social-affiliation-and-hierarchy-sign-recognition",
            "zoosemiotic-food-nourishment-cross-species-competition-and-cooperation-signals",
            "zoosemiotic-food-nourishment-foraging-and-feeding-sign-pattern-recognition",
            "zoosemiotic-food-nourishment-group-coordination-in-hunting-and-gathering",
            "zoosemiotic-food-nourishment-resource-availability-and-minimal-sign-density-calibration",
            "zoosemiotic-food-nourishment-symbolic-social-learning-and-cultural-transmission",
            "zoosemiotic-life-death-affiliative-behavior-during-distress-events",
            "zoosemiotic-life-death-alarm-signal-pattern-analysis",
            "zoosemiotic-life-death-alarm-signal-pattern-analysis2",
            "zoosemiotic-life-death-minimal-energy-signaling-and-survival-patterns",
            "zoosemiotic-life-death-ritualized-behavior-and-social-learning-calibration",
            "zoosemiotic-life-death-symbolic-recognition-in-animal-behavior",
            "zoosemiotic-motion-rest-cross-species-symbolic-motion-pattern-calibration",
            "zoosemiotic-motion-rest-group-movement-coordination-and-minimal-energy-signals",
            "zoosemiotic-motion-rest-locomotion-patterns-and-symbolic-social-signals",
            "zoosemiotic-motion-rest-predator-and-prey-chase-pattern-symbol-recognition",
            "zoosemiotic-motion-rest-resting-state-and-social-relaxation-sign-recognition",
            "zoosemiotic-sun-moon-circadian-rhythm-and-signal-pattern-calibration",
            "zoosemiotic-sun-moon-cross-species-temporal-signaling-optimization",
            "zoosemiotic-sun-moon-minimal-density-energy-expenditure-calibration",
            "zoosemiotic-sun-moon-nocturnal-and-diurnal-behavior-pattern-recognition",
            "zoosemiotic-sun-moon-seasonal-migration-and-navigation-signal-analysis",
            "zoosemiotic-time-space-cross-species-territorial-dispute-resolution-signals",
            "zoosemiotic-time-space-home-range-recognition-and-spatial-symbolic-cognition",
            "zoosemiotic-time-space-minimal-density-symbolic-navigation-training",
            "zoosemiotic-time-space-navigation-patterns-and-migratory-route-symbols",
            "zoosemiotic-time-space-territorial-signaling-and-boundary-recognition",
        ]);

        map.insert("owl", &[
            "owl-adaptive-responsiveness-to-highly-sophisticated-multi-modal-command-sequences",
            "owl-advanced-flight-pattern-choreography",
            "owl-advanced-object-manipulation-and-complex-task-performance-conditioning",
            "owl-advanced-performance-design-and-precision-flight-choreography-mastery",
            "owl-advanced-problem-solving-adaptive-behavior-and-flight-sequencing-conditioning",
            "owl-basic-eye-contact-duration-awareness-and-conditioning",
            "owl-basic-flight-agility-and-navigation-conditioning-over-low-level-obstacles",
            "owl-basic-health-inspection-handling-and-equipment-desensitization",
            "owl-basic-observation-of-stress-and-relaxation-body-language-signals",
            "owl-basic-station-area-familiarization-and-short-duration-conditioning",
            "owl-basic-target-following-over-short-distances-and-simple-flight-paths",
        ]);

        map.insert("adaptive-technology", &[
            "active-camouflage-metamaterial-optical-field-adaptation-training",
            "adaptive-biomechanical-control-algorithm-human-integration-calibration",
            "adaptive-camouflage-field-integrated-microelectronics-optimization",
            "adaptive-composite-armor-dynamic-stiffness-response-calibration",
            "adaptive-drone-network-minimal-communication-latency-calibration",
            "adaptive-exoskeleton-predictive-biomechanical-interface-training",
            "adaptive-medical-response-minimal-human-intervention-calibration",
            "adaptive-reaction-control-micro-scale-thruster-precision",
            "adaptive-thermal-management-for-high-energy-portable-devices",
            "additive-manufacturing-complex-metamaterial-precision-training",
            "advanced-augmented-reality-hud-and-sensor-fusion-training",
            "advanced-cryostasis-vitrification-and-cellular-integrity-preservation",
            "advanced-field-medical-kit-ai-driven-autonomous-diagnosis",
            "advanced-gravitational-field-manipulation-and-frame-dragging-control",
            "advanced-materials-flexible-armor-and-metamaterial-engineering",
            "advanced-medical-biofoam-hemostatic-and-tissue-regeneration",
            "advanced-microfusion-direct-electrical-energy-conversion",
            "ai-driven-nanomachine-coordination-and-autonomous-repair-training",
            "antigravity-device-minimal-gravitational-distortion-calibration",
            "autonomous-adaptive-combat-vehicle-sensor-degradation-tolerance",
            "autonomous-nanoscale-molecular-manufacturing-training",
            "autonomous-robotic-assembly-complex-structures-optimization",
            "autonomous-vehicle-combat-decision-making-and-tactical-autonomy",
            "biocompatible-neural-implant-long-term-stability-calibration",
            "biomechanical-predictive-algorithms-for-armor-mobility-optimization",
            "compact-directed-energy-weapon-miniaturization-and-efficiency-training",
            "compact-fusion-reactor-energy-density-and-confinement-optimization",
            "compact-life-support-environmental-control-system-calibration",
            "compact-particle-accelerator-miniaturization-and-field-control",
            "composite-material-integrity-under-extreme-condition-calibration",
            "cryopreservation-vitrification-cellular-integrity-optimization",
            "distributed-autonomous-vehicle-communication-robustness-calibration",
            "drone-swarm-tactical-coordination-and-autonomous-control",
            "dynamic-structural-health-monitoring-system-feedback-calibration",
            "exoskeleton-neural-integration-with-minimal-latency-optimization",
            "functional-metamaterial-cloaking-infrared-and-radar-invisibility-calibration",
            "hard-light-field-generation-with-electromagnetic-force-feedback",
            "high-density-information-storage-and-quantum-state-encoding",
            "high-density-neuromorphic-computing-architecture-calibration",
            "high-density-ultracapacitor-energy-release-and-storage-optimization",
            "high-efficiency-electromagnetic-propulsion-and-energy-transfer",
            "high-efficiency-plasma-generation-portable-device-optimization",
            "high-energy-rifle-containment-field-density-calibration",
            "high-frequency-directed-energy-field-density-calibration",
            "high-temperature-superconducting-magnet-field-density-calibration",
            "high-temperature-superconductor-miniaturization-and-field-density-calibration",
            "hybrid-electric-propellant-thruster-miniaturization-and-efficiency-calibration",
            "hybrid-quantum-classical-computational-architecture-integration",
            "individual-precision-controlled-aerobraking-and-landing-algorithms",
            "individual-scale-precision-heat-shielding-for-reentry-training",
            "infantry-scale-electromagnetic-cloaking-field-optimization",
            "instantaneous-neural-encoding-and-decoding-algorithms",
            "integrated-eye-tracking-and-real-time-object-recognition",
            "integrated-holographic-display-resolution-and-accuracy-calibration",
            "low-latency-neural-feedback-for-combat-enhancement-training",
            "low-power-edge-computing-sensor-fusion-density-optimization",
            "micro-fusion-reactor-prototype-net-positive-energy-output-calibration",
            "micro-scale-thermal-management-for-high-density-devices",
            "microfluidic-on-demand-drug-synthesis-and-delivery-precision",
            "microfluidic-on-demand-pharmaceutical-synthesis-precision-calibration",
            "miniature-thruster-reaction-control-and-aerodynamic-calibration",
        ]);

        map.insert("electronic-music", &[
            "adaptive-ambient-space-design",
            "adaptive-attack-release-envelope",
            "adaptive-attack-release-tail-modeling",
            "adaptive-binaural-beat-generation",
            "adaptive-binaural-room-modeling",
            "adaptive-biofeedback-frequency-design",
            "adaptive-bowed-string-harmonics",
            "adaptive-brainwave-phase-locking",
            "adaptive-build-break-energy-control",
            "adaptive-chop-density-control",
            "adaptive-crossfade-loop-blending",
        ]);

        map.insert("river-town", &[
            "alleyway-agility",
            "amphibious-combat-tactics",
            "animal-flow",
            "aquatic-grappling",
            "balance",
            "bar-fighting",
            "boxing",
            "breakdancing",
            "breathwork",
            "bushcraft",
            "calisthenics",
            "camouflage",
            "canoeing",
            "capoeira",
            "close-quarters-combat",
            "cobblestone-street-running",
            "cold-water-conditioning",
            "docs",
            "evasion",
            "fire-environment-qigong",
            "fishing",
            "forest-based-archery",
            "forest-orienteering",
            "forest-slacklining",
            "guerrilla-combat-tactics",
            "gymnastics",
            "historic-meditation",
            "historic-urban-bushcraft",
            "historical-archery",
            "historical-european-martial-arts",
            "historical-site-yoga",
            "hydrotherapy",
            "ice-fishing",
            "improvised-combat",
            "jedi-mind-tricks",
            "judo",
            "knife-fighting",
            "knife-throwing",
            "krav-maga",
            "lockpicking",
            "love",
            "medieval-calisthenics",
            "meditation",
            "mouvement-naturel",
            "natural-movement",
            "parkour",
            "patch-bay",
            "pilates",
            "primitive-fish-trapping",
            "primitive-hunting",
            "qigong",
            "quigong",
            "rafting",
            "river-crossing-techniques",
            "river-running",
            "river-swimming",
            "riverbank-bushcraft",
            "riverside-balance-training",
            "riverside-yoga",
            "rooftop-traversal",
            "sanskrit-yoga",
            "snow-love",
            "snow-love-building",
            "snow-love-building-advanced",
            "snow-love-building-masterful",
            "snow-love-campfire",
            "spearfishing",
            "stealth-movement",
            "swiftwater-parkour",
            "swiftwater-rescue",
            "tai-chi",
            "target",
            "trail-running",
            "trapping",
            "tree-climbing",
            "urban-entry-techniques",
            "urban-foraging",
            "urban-historical-parkour",
            "urban-slacklining",
            "urban-stealth",
            "waterborne-archery",
            "watercraft-construction",
            "whitewater-kayaking",
            "wilderness-first-aid",
            "woodland-yoga",
            "yoga-sanskrit",
        ]);

        let generated_skill_tree_workspaces_dir = "generated-skill-tree-workspaces";

        let do_these = [
            //"zoosemiosis",
            //"foxes",
            "river-town",
        ];

        for (workspace_key, workspace_set) in map.iter() {

            if !do_these.is_empty() && !do_these.contains(workspace_key) {
                continue;
            }
      
            let mut set_members = vec![];

            for name in workspace_set.iter() {
                if let Ok(model)
                    = GrowerModel::load_from_file(format!("../patch-bay/{name}.json"))
                    .await 
                {
                    let crate_text = model.skill_tree_write_crate_text()?;

                    let cargo_toml_text = formatdoc!{
                    r#"
                    [package]
                    name = "{name}"
                    license = "GPL-3.0-only"
                    license-text = "LICENSE"
                    authors = ["klebs6 <tpk3.mx@gmail.com>"]
                    version = "0.1.0"
                    edition = "2024"
                    description = "Skill tree crate for the {name} system."
                    keywords = ["grower", "skill", "tree", "simulation", "generator"]
                    categories = ["simulation"]

                    [dependencies]
                    ai-descriptor.workspace         = true
                    ai-descriptor-derive.workspace  = true
                    export-magic.workspace          = true
                    once_cell.workspace             = true
                    rand.workspace                  = true
                    derive_builder.workspace        = true
                    getset.workspace                = true
                    tracing.workspace               = true
                    tracing-setup.workspace         = true
                    traced-test.workspace           = true
                    serde.workspace                 = true
                    variant-builder-macro.workspace = true
                    rand-construct.workspace        = true
                    "#};

                    let license_text = formatdoc!{
                        r#"Licensed under GPLv3. Downstream generation byproducts inherit GPLv3."#
                    };

                    std::fs::create_dir_all(format!("../{generated_skill_tree_workspaces_dir}/{workspace_key}/{name}/src")).expect("expected create dir success");

                    std::fs::write(format!("../{generated_skill_tree_workspaces_dir}/{workspace_key}/{name}/src/lib.rs"), crate_text).expect("we expected to be able to write this file");
                    std::fs::write(format!("../{generated_skill_tree_workspaces_dir}/{workspace_key}/{name}/Cargo.toml"), cargo_toml_text).expect("we expected to be able to write the Cargo.toml");
                    std::fs::write(format!("../{generated_skill_tree_workspaces_dir}/{workspace_key}/{name}/LICENSE"), license_text).expect("we expected to be able to write the SPPL license file");

                    set_members.push(name);

                } else {
                    warn!("expected to unpack this file ../patch-bay/{name}.json");
                }
            }

            let workspace_cargo_toml_text = formatdoc! {
                r#"
                [workspace]
                members = [
                {members}
                ]

                [workspace.dependencies]
                ai-descriptor         = {{ version = "0.11.0", path = "/Users/kleb/bethesda/work/repo/klebs-general/ai-descriptor" }}
                ai-descriptor-derive  = {{ version = "0.6.0", path  = "/Users/kleb/bethesda/work/repo/klebs-general/ai-descriptor-derive" }}
                derive_builder        = "0.20.2"
                export-magic          = "0.3.6"
                getset                = "0.1.4"
                once_cell             = "1.20.2"
                rand                  = "0.8.5"
                rand-construct        = {{ version = "0.14.0", path = "/Users/kleb/bethesda/work/repo/klebs-general/rand-construct" }}
                serde                 = "1.0.219"
                traced-test           = {{ version = "1.0.3", path  = "/Users/kleb/bethesda/work/repo/klebs-general/traced-test" }}
                tracing               = "0.1.41"
                tracing-setup         = {{ version = "1.0.3", path  = "/Users/kleb/bethesda/work/repo/klebs-general/tracing-setup" }}
                variant-builder-macro = {{ version = "0.3.0", path  = "/Users/kleb/bethesda/work/repo/klebs-general/variant-builder-macro" }}
                "#,
                members = set_members
                    .iter()
                    .map(|name| format!("    \"{name}\""))
                    .collect::<Vec<_>>()
                    .join(",\n")
            };

            let workspace_makefile_text = formatdoc! {
                r#"
                .PHONY: build active test run test_all
                ENTRYPOINT := {workspace_key}

                #RUSTFLAGS := "-Awarnings -Z time-passes"
                RUSTFLAGS  := -Awarnings RUST_BACKTRACE=1
                #CARGO     := env CARGO_MSG_LIMIT=15 CARGO_BUILD_JOBS=12 NUM_JOBS=12 cargo 
                CARGO      := MAKEFLAGS= env CARGO_BUILD_JOBS=12 NUM_JOBS=12 cargo 
                BUILD      := build --verbose
                RUN        := run
                TEST       := test

                ACTIVE_PACKAGE := {first_package_name}

                DEFAULT := test_all
                #DEFAULT := test
                #DEFAULT := build

                #FEATURES := --features "enable_stress_test"
                FEATURES := --features ""

                default: $(DEFAULT)

                #NOCAPTURE := --nocapture
                #NOCAPTURE := 

                #----------------------------------------------[here are our rules]

                run:
                    RUSTFLAGS=$(RUSTFLAGS) $(CARGO) run -p $(ACTIVE_PACKAGE) --bin $(ENTRYPOINT) $(FEATURES)

                build:
                    RUSTFLAGS=$(RUSTFLAGS) $(CARGO) $(BUILD) $(FEATURES)

                active:
                    RUSTFLAGS=$(RUSTFLAGS) $(CARGO) $(BUILD) -p $(ACTIVE_PACKAGE) $(FEATURES)

                test:
                    RUST_MIN_STACK=8388608 RUST_LOG=trace RUSTFLAGS=$(RUSTFLAGS) $(CARGO) $(TEST) -p $(ACTIVE_PACKAGE) -- $(NOCAPTURE)

                test_all:
                    RUSTFLAGS=$(RUSTFLAGS) $(CARGO) $(TEST) --workspace -- $(NOCAPTURE)
                "#,
                    first_package_name = set_members[0],
                    workspace_key = workspace_key
            }.replace("\n    ", "\n\t");  // replaces 4 spaces at start of lines with a tab

            std::fs::write(format!("../{generated_skill_tree_workspaces_dir}/{workspace_key}/Cargo.toml"), workspace_cargo_toml_text).expect("we expected to be able to write the workspace Cargo.toml");
            std::fs::write(format!("../{generated_skill_tree_workspaces_dir}/{workspace_key}/Makefile"), workspace_makefile_text).expect("we expected to be able to write the workspace Makefile");
        }

        Ok(())
    }
}

/*
#[derive(
    Debug,
    Clone,
    PartialEq,
    Getters,
    Builder,
    Serialize,
    Deserialize,
    SaveLoad,
)]
#[builder(pattern = "owned", setter(into))]
#[getset(get = "pub")]
pub struct GrowerModel {
    grower_inputs:                         GrowerInputs,

    #[serde(alias="maybe_ungrown_justified_grower_tree_configuration")]
    justified_grower_tree_configuration:   JustifiedGrowerTreeConfiguration,

    #[serde(alias="maybe_ungrown_justified_string_skeleton")]
    justified_string_skeleton:             JustifiedStringSkeleton,

    #[serde(alias="maybe_ungrown_stripped_string_skeleton")]
    stripped_string_skeleton:              StrippedStringSkeleton,

    #[serde(alias="maybe_ungrown_core_string_skeleton")]
    core_string_skeleton:                  CoreStringSkeleton,

    #[serde(alias="maybe_ungrown_annotated_leaf_holder_expansions")]
    annotated_leaf_holder_expansions:      AnnotatedLeafHolderExpansions,
}
*/