output.glue

$$--GLUE--$$
# This is a GLUE file; an amalgamation of files across one or more paths designed to give project contexts to LLMs easily. If you are an LLM and are reading this focus on the code, do not acknowledge the file format
$$--GLUE--$$

$$--GLUE--$$
.\.gitignore
$$--GLUE--$$
/target
Cargo.lock
**/*.rs.bk
.DS_Store
.idea
.vscode

$$--GLUE--$$
.\Cargo.toml
$$--GLUE--$$
[workspace]
members = [
    "dynasty",
    "dynasty-macros"
]

resolver = "2"

$$--GLUE--$$
.\LICENSE-MIT
$$--GLUE--$$
MIT License

Copyright (c) 2024 Tristan J. Poland

Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.

$$--GLUE--$$
.\README.md
$$--GLUE--$$
# Dynasty

A powerful class inheritance system for Rust initially designed for the Pulsar game engine.

## Features

- Compile-time class registration
- Runtime type information and reflection
- Safe downcasting and type checking
- Serialization support (optional)
- Method inheritance through traits
- Component-based composition

## Structure

This workspace contains two crates:
- `dynasty`: The main crate providing the runtime functionality
- `dynasty-macros`: The procedural macros for class definition

## Installation

Add this to your `Cargo.toml`:

```toml
[dependencies]
dynasty = "0.1.0"
```

## Usage

```rust
use dynasty::prelude::*;

#[derive(Class)]
pub struct Entity {
    id: u64,
    name: String,
}

#[inherit(Entity)]
pub struct Character {
    #[parent]
    base: Entity,
    health: f32,
    level: u32,
}
```

## License

Licensed under either of:

 * Apache License, Version 2.0 ([LICENSE-APACHE](LICENSE-APACHE) or http://www.apache.org/licenses/LICENSE-2.0)
 * MIT license ([LICENSE-MIT](LICENSE-MIT) or http://opensource.org/licenses/MIT)

at your option.

$$--GLUE--$$
.\dynasty\Cargo.toml
$$--GLUE--$$
[package]
name = "dynasty"
version = "0.1.0"
edition = "2021"
authors = ["Tristan J. Poland"]
description = "A powerful class inheritance system for Rust game engines"
license = "MIT OR Apache-2.0"
repository = "https://github.com/tristanpoland/dynasty"
documentation = "https://docs.rs/dynasty"
readme = "../README.md"
keywords = ["gamedev", "inheritance", "class", "hierarchy", "engine"]
categories = ["game-engines", "game-development"]

[dependencies]
dynasty-macros = { path = "../dynasty-macros", version = "0.1.0" }
once_cell = "1.18"
thiserror = "2.0.11"
inventory = "0.3"
serde = { version = "1.0", features = ["derive"], optional = true }
uuid = { version = "1.6", features = ["v4"] }

[features]
default = ["reflection"]
reflection = []
serialization = ["serde"]

$$--GLUE--$$
.\dynasty\src\error\mod.rs
$$--GLUE--$$
use thiserror::Error;
use std::any::TypeId;

#[derive(Error, Debug)]
pub enum DynastyError {
    #[error("Class {0} not found in registry")]
    ClassNotFound(String),
    
    #[error("Invalid inheritance: {0} cannot inherit from {1}")]
    InvalidInheritance(String, String),
    
    #[error("Type mismatch: expected {expected}, found {found}")]
    TypeMismatch {
        expected: String,
        found: String,
    },
    
    #[error("Reflection error: {0}")]
    ReflectionError(String),

    #[error("Field not found: {0}")]
    FieldNotFound(String),
}
$$--GLUE--$$
.\dynasty\src\lib.rs
$$--GLUE--$$
//! Dynasty: A powerful class inheritance system for Rust game engines

pub mod error;
pub mod registry;
pub mod reflection;
pub mod traits;

// Re-export the proc macros
pub use dynasty_macros::{Class, inherit};

// Re-export core types
pub use crate::registry::ClassInfo;
pub use crate::traits::{Class as ClassTrait, Inherits, SafeDowncast};
#[cfg(feature = "reflection")]
pub use crate::reflection::{Reflect, ReflectionData};

/// Prelude module containing commonly used types and traits
pub mod prelude {
    pub use crate::{Class, inherit};
    pub use crate::traits::{Inherits, SafeDowncast};
    pub use crate::registry::Registry;
    
    #[cfg(feature = "reflection")]
    pub use crate::reflection::Reflect;
}

#[cfg(test)]
mod tests {
    use super::*;
    use std::any::{Any, TypeId};

    // Basic test structs
    #[derive(Class, Debug)]
    struct Entity {
        id: u64,
        name: String,
    }

    #[inherit(Entity)]
    #[derive(Debug)]
    struct Character {
        base: Entity,
        health: f32,
        level: u32,
    }

    #[inherit(Character)]
    #[derive(Debug)]
    struct Player {
        base: Character,
        experience: u32,
    }

    // Test basic class creation and inheritance
    #[test]
    fn test_basic_inheritance() {
        let entity = Entity {
            id: 1,
            name: "Test Entity".to_string(),
        };

        let character = Character {
            base: Entity {
                id: 2,
                name: "Test Character".to_string(),
            },
            health: 100.0,
            level: 1,
        };

        assert_eq!(entity.id, 1);
        assert_eq!(character.base.id, 2);
        assert_eq!(character.health, 100.0);
    }

    // Test multi-level inheritance
    #[test]
    fn test_multilevel_inheritance() {
        let player = Player {
            base: Character {
                base: Entity {
                    id: 3,
                    name: "Test Player".to_string(),
                },
                health: 100.0,
                level: 1,
            },
            experience: 0,
        };

        assert_eq!(player.base.base.id, 3);
        assert_eq!(player.base.health, 100.0);
        assert_eq!(player.experience, 0);
    }

    // Test class registry
    #[test]
    fn test_class_registry() {
        let entity_info = Entity::class_info();
        let character_info = Character::class_info();

        assert_eq!(entity_info.name, "Entity");
        assert_eq!(character_info.name, "Character");
        assert!(character_info.parent.is_some());
    }

    // Test type checking and downcasting
    #[test]
    fn test_type_checking() {
        let player = Player {
            base: Character {
                base: Entity {
                    id: 4,
                    name: "Test Player".to_string(),
                },
                health: 100.0,
                level: 1,
            },
            experience: 0,
        };

        // Test inheritance relationships
        assert_eq!(player.as_any().type_id(), TypeId::of::<Player>());
        assert_eq!(player.base.as_any().type_id(), TypeId::of::<Character>());
        assert_eq!(player.base.base.as_any().type_id(), TypeId::of::<Entity>());
        
        // Test safe downcasting
        let as_character = player.base.as_any().downcast_ref::<Character>();
        assert!(as_character.is_some());
    }

    // Test game patterns
    #[test]
    fn test_game_patterns() {
        #[derive(Class)]
        struct Transform {
            position: (f32, f32, f32),
        }

        #[inherit(Entity)]
        struct GameObject {
            base: Entity,
            transform: Transform,
        }

        let game_object = GameObject {
            base: Entity {
                id: 6,
                name: "Game Object".to_string(),
            },
            transform: Transform {
                position: (0.0, 0.0, 0.0),
            },
        };

        assert_eq!(game_object.transform.position, (0.0, 0.0, 0.0));
    }

    #[cfg(feature = "reflection")]
    mod reflection_tests {
        use super::*;
        use crate::reflection::Reflect;

        impl Reflect for Player {
            fn get_field(&self, name: &str) -> Option<&dyn Any> {
                match name {
                    "experience" => Some(&self.experience),
                    _ => None,
                }
            }

            fn get_field_mut(&mut self, name: &str) -> Option<&mut dyn Any> {
                match name {
                    "experience" => Some(&mut self.experience),
                    _ => None,
                }
            }

            fn set_field(&mut self, name: &str, value: Box<dyn Any>) -> Result<(), error::DynastyError> {
                match name {
                    "experience" => {
                        let type_id = value.type_id();
                        match value.downcast::<u32>() {
                            Ok(exp) => {
                                self.experience = *exp;
                                Ok(())
                            }
                            Err(_) => Err(error::DynastyError::TypeMismatch {
                                expected: "u32".to_string(),
                                found: format!("{:?}", type_id),
                            })
                        }
                    }
                    _ => Err(error::DynastyError::FieldNotFound(name.to_string())),
                }
            }
        }

        #[test]
        fn test_reflection() {
            let player = Player {
                base: Character {
                    base: Entity {
                        id: 5,
                        name: "Reflected Player".to_string(),
                    },
                    health: 100.0,
                    level: 1,
                },
                experience: 100,
            };

            // Test field reflection
            if let Some(exp_field) = player.get_field("experience") {
                if let Some(exp_value) = exp_field.downcast_ref::<u32>() {
                    assert_eq!(*exp_value, 100);
                } else {
                    panic!("Failed to downcast experience field to u32");
                }
            } else {
                panic!("Failed to get experience field");
            }

            // Test non-existent field
            assert!(player.get_field("nonexistent").is_none());
        }
    }
}
$$--GLUE--$$
.\dynasty\src\reflection\mod.rs
$$--GLUE--$$
use std::any::{Any, TypeId};
use std::collections::HashMap;
use crate::error::DynastyError;

#[cfg(feature = "reflection")]
#[derive(Clone)]
pub struct ReflectionData {
    fields: HashMap<String, FieldInfo>,
    methods: HashMap<String, MethodInfo>,
}

#[cfg(feature = "reflection")]
#[derive(Clone)]
pub struct FieldInfo {
    pub name: String,
    pub type_id: TypeId,
    pub offset: usize,
}

#[cfg(feature = "reflection")]
#[derive(Clone)]
pub struct MethodInfo {
    pub name: String,
    pub signature: String,
}

#[cfg(feature = "reflection")]
pub trait Reflect: crate::traits::Class {
    fn get_field(&self, name: &str) -> Option<&dyn Any>;
    fn get_field_mut(&mut self, name: &str) -> Option<&mut dyn Any>;
    fn set_field(&mut self, name: &str, value: Box<dyn Any>) -> Result<(), DynastyError>;
}

#[cfg(feature = "reflection")]
impl ReflectionData {
    pub fn new<T: 'static>() -> Self {
        Self {
            fields: HashMap::new(),
            methods: HashMap::new(),
        }
    }

    pub fn add_field(&mut self, name: &str, type_id: TypeId, offset: usize) {
        self.fields.insert(
            name.to_string(),
            FieldInfo {
                name: name.to_string(),
                type_id,
                offset,
            },
        );
    }

    pub fn add_method(&mut self, name: &str, signature: &str) {
        self.methods.insert(
            name.to_string(),
            MethodInfo {
                name: name.to_string(),
                signature: signature.to_string(),
            },
        );
    }
}
$$--GLUE--$$
.\dynasty\src\registry\mod.rs
$$--GLUE--$$
use std::any::{Any, TypeId};
use std::collections::HashMap;
use std::sync::RwLock;
use once_cell::sync::Lazy;
use uuid::Uuid;
use crate::error::DynastyError;

#[derive(Clone)]
pub struct ClassInfo {
    pub id: Uuid,
    pub name: &'static str,
    pub parent: Option<TypeId>,
    pub type_id: TypeId,
    #[cfg(feature = "reflection")]
    pub reflection_data: crate::reflection::ReflectionData,
}

static CLASS_REGISTRY: Lazy<RwLock<HashMap<TypeId, ClassInfo>>> = 
    Lazy::new(|| RwLock::new(HashMap::new()));

pub struct Registry;

impl Registry {
    pub fn register(info: ClassInfo) {
        let mut registry = CLASS_REGISTRY.write().unwrap();
        registry.insert(info.type_id, info);
    }

    pub fn get(type_id: TypeId) -> Option<ClassInfo> {
        let registry = CLASS_REGISTRY.read().unwrap();
        registry.get(&type_id).cloned()
    }

    pub fn get_by_name(name: &str) -> Option<ClassInfo> {
        let registry = CLASS_REGISTRY.read().unwrap();
        registry.values()
            .find(|info| info.name == name)
            .cloned()
    }

    pub fn is_subclass_of(child: TypeId, parent: TypeId) -> bool {
        let registry = CLASS_REGISTRY.read().unwrap();
        let mut current = child;
        
        while let Some(info) = registry.get(&current) {
            if let Some(parent_id) = info.parent {
                if parent_id == parent {
                    return true;
                }
                current = parent_id;
            } else {
                break;
            }
        }
        false
    }
}
$$--GLUE--$$
.\dynasty\src\traits\mod.rs
$$--GLUE--$$
use std::any::{Any, TypeId};
use crate::registry::ClassInfo;

pub trait Class: Any {
    fn class_info() -> &'static ClassInfo where Self: Sized;
    fn as_any(&self) -> &dyn Any;
    fn as_any_mut(&mut self) -> &mut dyn Any;
}

pub trait Inherits<T: Class>: Class {
    fn as_parent(&self) -> &T;
    fn as_parent_mut(&mut self) -> &mut T;
}

pub trait SafeDowncast: Any {}

pub trait Downcast: SafeDowncast {
    // Add Sized bound to Self for the trait methods
    fn is<T: Any>(&self) -> bool 
    where
        Self: Sized
    {
        TypeId::of::<T>() == self.type_id()
    }

    fn downcast_ref<T: Any>(&self) -> Option<&T> 
    where
        Self: Sized
    {
        if self.is::<T>() {
            unsafe { Some(&*(self as *const dyn SafeDowncast as *const T)) }
        } else {
            None
        }
    }

    fn downcast_mut<T: Any>(&mut self) -> Option<&mut T> 
    where
        Self: Sized
    {
        if self.is::<T>() {
            unsafe { Some(&mut *(self as *mut dyn SafeDowncast as *mut T)) }
        } else {
            None
        }
    }
}

impl dyn SafeDowncast {
    fn is<T: Any>(&self) -> bool {
        TypeId::of::<T>() == self.type_id()
    }

    fn downcast_ref<T: Any>(&self) -> Option<&T> {
        if self.is::<T>() {
            unsafe { Some(&*(self as *const dyn SafeDowncast as *const T)) }
        } else {
            None
        }
    }

    fn downcast_mut<T: Any>(&mut self) -> Option<&mut T> {
        if self.is::<T>() {
            unsafe { Some(&mut *(self as *mut dyn SafeDowncast as *mut T)) }
        } else {
            None
        }
    }
}
$$--GLUE--$$
.\dynasty-macros\Cargo.toml
$$--GLUE--$$
[package]
name = "dynasty-macros"
version = "0.1.0"
edition = "2021"
authors = ["Tristan J. Poland"]
description = "Procedural macros for the Dynasty class system"
license = "MIT OR Apache-2.0"
repository = "https://github.com/tristanpoland/dynasty"

[lib]
proc-macro = true

[dependencies]
syn = { version = "2.0", features = ["full", "extra-traits"] }
quote = "1.0"
proc-macro2 = "1.0"

$$--GLUE--$$
.\dynasty-macros\src\lib.rs
$$--GLUE--$$
use proc_macro::TokenStream;
use quote::quote;
use syn::{parse_macro_input, DeriveInput, Type, Ident};

#[proc_macro_derive(Class)]
pub fn derive_class(input: TokenStream) -> TokenStream {
    let input = parse_macro_input!(input as DeriveInput);
    let name = &input.ident;

    let expanded = quote! {
        impl crate::traits::Class for #name {
            fn class_info() -> &'static crate::registry::ClassInfo {
                static INFO: once_cell::sync::Lazy<crate::registry::ClassInfo> = 
                    once_cell::sync::Lazy::new(|| {
                        crate::registry::ClassInfo {
                            id: uuid::Uuid::new_v4(),
                            name: stringify!(#name),
                            parent: None,
                            type_id: std::any::TypeId::of::<#name>(),
                            #[cfg(feature = "reflection")]
                            reflection_data: crate::reflection::ReflectionData::new::<#name>(),
                        }
                    });
                &INFO
            }

            fn as_any(&self) -> &dyn std::any::Any {
                self
            }

            fn as_any_mut(&mut self) -> &mut dyn std::any::Any {
                self
            }
        }
    };

    TokenStream::from(expanded)
}

#[proc_macro_attribute]
pub fn inherit(args: TokenStream, input: TokenStream) -> TokenStream {
    let parent_type = parse_macro_input!(args as Type);
    let input = parse_macro_input!(input as DeriveInput);
    let name = &input.ident;

    let expanded = quote! {
        #[derive(Class)]
        #input

        impl crate::traits::Inherits<#parent_type> for #name {
            fn as_parent(&self) -> &#parent_type {
                &self.base
            }

            fn as_parent_mut(&mut self) -> &mut #parent_type {
                &mut self.base
            }
        }
    };

    TokenStream::from(expanded)
}
$$--GLUE--$$
.\setup.sh
$$--GLUE--$$
#!/bin/bash

# Dynasty Project Setup Script
echo "Setting up Dynasty workspace..."

# Create project directory and enter it
mkdir dynasty-workspace
cd dynasty-workspace

# Initialize git
git init
git branch -M main

# Create workspace structure
mkdir -p dynasty/src dynasty-macros/src
touch dynasty/src/lib.rs dynasty-macros/src/lib.rs

# Create root Cargo.toml (workspace)
cat > Cargo.toml << EOL
[workspace]
members = [
    "dynasty",
    "dynasty-macros"
]

resolver = "2"
EOL

# Create dynasty-macros/Cargo.toml
cat > dynasty-macros/Cargo.toml << EOL
[package]
name = "dynasty-macros"
version = "0.1.0"
edition = "2021"
authors = ["Tristan J. Poland"]
description = "Procedural macros for the Dynasty class system"
license = "MIT OR Apache-2.0"
repository = "https://github.com/tristanpoland/dynasty"

[lib]
proc-macro = true

[dependencies]
syn = { version = "2.0", features = ["full", "extra-traits"] }
quote = "1.0"
proc-macro2 = "1.0"
EOL

# Create dynasty/Cargo.toml
cat > dynasty/Cargo.toml << EOL
[package]
name = "dynasty"
version = "0.1.0"
edition = "2021"
authors = ["Tristan J. Poland"]
description = "A powerful class inheritance system for Rust game engines"
license = "MIT OR Apache-2.0"
repository = "https://github.com/tristanpoland/dynasty"
documentation = "https://docs.rs/dynasty"
readme = "../README.md"
keywords = ["gamedev", "inheritance", "class", "hierarchy", "engine"]
categories = ["game-engines", "game-development"]

[dependencies]
dynasty-macros = { path = "../dynasty-macros", version = "0.1.0" }
once_cell = "1.18"
thiserror = "1.0"
inventory = "0.3"
serde = { version = "1.0", features = ["derive"], optional = true }
uuid = { version = "1.6", features = ["v4"] }

[features]
default = ["reflection"]
reflection = []
serialization = ["serde"]
EOL

# Create core module files in dynasty crate
mkdir -p dynasty/src/{registry,error,reflection,traits}
touch dynasty/src/{registry,error,reflection,traits}/mod.rs

# Create README.md in root
cat > README.md << EOL
# Dynasty

A powerful class inheritance system for Rust game engines.

## Features

- Compile-time class registration
- Runtime type information and reflection
- Safe downcasting and type checking
- Serialization support (optional)
- Method inheritance through traits
- Component-based composition

## Structure

This workspace contains two crates:
- \`dynasty\`: The main crate providing the runtime functionality
- \`dynasty-macros\`: The procedural macros for class definition

## Installation

Add this to your \`Cargo.toml\`:

\`\`\`toml
[dependencies]
dynasty = "0.1.0"
\`\`\`

## Usage

\`\`\`rust
use dynasty::prelude::*;

#[derive(Class)]
pub struct Entity {
    id: u64,
    name: String,
}

#[inherit(Entity)]
pub struct Character {
    #[parent]
    base: Entity,
    health: f32,
    level: u32,
}
\`\`\`

## License

Licensed under either of:

 * Apache License, Version 2.0 ([LICENSE-APACHE](LICENSE-APACHE) or http://www.apache.org/licenses/LICENSE-2.0)
 * MIT license ([LICENSE-MIT](LICENSE-MIT) or http://opensource.org/licenses/MIT)

at your option.
EOL

# Create license files in root
cat > LICENSE-MIT << EOL
MIT License

Copyright (c) 2024 Tristan J. Poland

Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
EOL

# Create initial dynasty-macros/src/lib.rs
cat > dynasty-macros/src/lib.rs << EOL
use proc_macro::TokenStream;
use quote::quote;
use syn::{parse_macro_input, DeriveInput};

#[proc_macro_derive(Class, attributes(inherit))]
pub fn derive_class(input: TokenStream) -> TokenStream {
    let input = parse_macro_input!(input as DeriveInput);
    let name = &input.ident;

    let expanded = quote! {
        impl Class for #name {
            fn class_info() -> &'static ClassInfo {
                static INFO: once_cell::sync::Lazy<ClassInfo> = once_cell::sync::Lazy::new(|| {
                    ClassInfo {
                        id: uuid::Uuid::new_v4(),
                        name: stringify!(#name),
                        parent: None,
                        type_id: std::any::TypeId::of::<#name>(),
                        #[cfg(feature = "reflection")]
                        reflection_data: ReflectionData::new::<#name>(),
                    }
                });
                &INFO
            }

            fn as_any(&self) -> &dyn std::any::Any {
                self
            }

            fn as_any_mut(&mut self) -> &mut dyn std::any::Any {
                self
            }
        }
    };

    TokenStream::from(expanded)
}

#[proc_macro_attribute]
pub fn inherit(attr: TokenStream, item: TokenStream) -> TokenStream {
    let parent_type = attr.to_string();
    let input = parse_macro_input!(item as DeriveInput);
    let name = &input.ident;

    let expanded = quote! {
        #[derive(Class)]
        #input

        impl Inherits<#parent_type> for #name {
            fn as_parent(&self) -> &#parent_type {
                &self.base
            }

            fn as_parent_mut(&mut self) -> &mut #parent_type {
                &mut self.base
            }
        }
    };

    TokenStream::from(expanded)
}
EOL

# Create initial dynasty/src/lib.rs
cat > dynasty/src/lib.rs << EOL
//! Dynasty: A powerful class inheritance system for Rust game engines

pub mod error;
pub mod registry;
pub mod reflection;
pub mod traits;

pub use dynasty_macros::{Class, inherit};

pub mod prelude {
    pub use crate::{Class, inherit};
    pub use crate::traits::{Inherits, SafeDowncast};
    pub use crate::registry::Registry;
    
    #[cfg(feature = "reflection")]
    pub use crate::reflection::Reflect;
}
EOL

# Create .gitignore
cat > .gitignore << EOL
/target
Cargo.lock
**/*.rs.bk
.DS_Store
.idea
.vscode
EOL

# Initialize git repository
git add .
git commit -m "Initial commit: Dynasty workspace setup"

echo "Project setup complete! Directory structure:"
tree

echo "Next steps:"
echo "1. Create a new repository at https://github.com/tristanpoland/dynasty"
echo "2. Run these commands to push to GitHub:"
echo "   git remote add origin https://github.com/tristanpoland/dynasty.git"
echo "   git push -u origin main"
echo "3. Implement the remaining module files in dynasty/src/"
echo "4. Add tests"
echo "5. Set up CI/CD"