naxzyu/dialogos

Dialogos: Pioneering Interactive Narratives and Language Proficiency with Enhanced AI in Unity

🎭 Dialogos: A New Era in AI Communication

Dialogos stands at the vanguard of conversational AI, offering a transformative experience in human-AI interaction. The name "Dialogos" hails from the ancient Greek "διάλογος," meaning a "flow of words" or "conversation," reflecting the Socratic method of seeking truth through dialogue.

Embracing the Socratic tradition, Dialogos is not merely a tool but a bridge linking the wisdom of ancient philosophy with cutting-edge technology, fostering a profound connection between humans and AI.

Integrated with Unity, Dialogos delivers an immersive experience, making language learning an extraordinary adventure.

Key Highlights

• 🛠️ Innovative Fusion: Merging Unity's dynamic tools with Dialogos' linguistic agility for an engaging learning environment.
• 🧠 AI Supercharged: Harnessing advanced AI for immediate language insights, facilitating effortless mastery.
• 🎮 Playful Learning: Transforming language acquisition into a captivating quest filled with challenges.
• 👥 Tech for All: Providing an accessible portal to sophisticated language learning for diverse audiences.

Embark on the Dialogos Odyssey

Join the Dialogos journey—where cutting-edge tech meets the art of language, enabling you to explore new linguistic territories with enjoyment! Dialogos invites you to a world where languages unfold through engaging dialogue.

---

🚀 Launch Your Adventure with Dialogos

Embark on your journey with Dialogos by integrating the constellation of code into your etheral digital realm:

git clone https://github.com/p3nGu1nZz/Dialogos.git --recurse-submodules
cd Dialogos
# Unravel the mysteries of installation with our comprehensive guides

After restarting your console, please read our Getting Started Bootstrap Guide (todo:link) for detailed information on this process and how to use it properly.

How to Use Dialogos

Plunge into the essence of Dialogos with this code snippet, showcasing the finesse of conversational AI:

// Initialize the Dialogos model
DialogosModel dialogos = new DialogosModel();

// Engage in a dialogue with the model
string userInput = "Hello, Dialogos! How can you assist me today?";
string dialogosResponse = dialogos.Converse(userInput);

// Display the model's response
Console.WriteLine("Dialogos: " + dialogosResponse);

/* Example interaction (this is a conceptual representation, not actual output):
User:     Hello, Dialogos! How can you assist me today?
Dialogos: Greetings! I'm here to guide you through learning new languages, 
          practicing conversations, or delving into interactive narratives. 
          What adventure shall we embark on today?
*/

Community Contributions

Embark on the odyssey of innovation! Your insights and code are the cornerstones of our collective journey.

License

Dialogos is bestowed upon the world as a free and open-source gem, under the MIT License. Delve into the legal text within the LICENSE file.

Connect with the Pioneers

Forge connections with the intellects behind Dialogos: NaXzyu - @NaXzyu p3nGu1nZz - @p3ngu1nzz Explore further in our digital sanctum: Dialogos on GitHub

💖 Special Thanks

A cosmos of appreciation to:

• The visionaries at Unity Technologies for their unparalleled platform
• The vanguards of the ML-Agents Community for pushing the boundaries of AI
• Each contributor who has enriched Dialogos with their distinctive essence

@misc{Dialogos,
  author = {NaXzyu, p3nGu1nZz},
  title = {Dialogos - Dialogos: Harnessing the power of language through Unity-driven AI.},
  year = {2024},
  publisher = {GitHub},
  journal = {GitHub repository},
  howpublished = {\url{https://github.com/NaXzyu/Dialogos}}
}

dialogos's Issues

Implement Cleanup Subroutine for Miniconda Post Setup in `setup.bat`

Overview

This ticket outlines the need for a cleanup subroutine in our setup.bat script to remove Miniconda after the initial setup process is complete.

Objective

The goal is to ensure that any temporary files or configurations added during the Miniconda setup are properly removed, preventing potential conflicts or clutter in the system.

Tasks

• Identify all temporary files and configurations created by Miniconda setup.
• Develop a cleanup subroutine that can be called post Miniconda setup.
• Integrate the cleanup subroutine into the existing setup.bat script.
• Test the subroutine to ensure it effectively cleans up without affecting the system negatively.
• Document the subroutine and its impact on the setup process.

Acceptance Criteria

• The cleanup subroutine should run automatically after Miniconda setup is complete.
• The system should be left in a clean state, with no residual files or configurations from Miniconda setup.
• The setup.bat script should execute without errors on Windows environments.

Please feel free to adjust the content as needed to fit the specifics of your project's requirements.

Chore : Implement Minimal FileSystem Class for DialogosEngine

1. Design Phase

• 1.1. Define the class structure and interfaces.
  • 1.1.1. Identify all necessary file operations (e.g., read, write, delete).
  • 1.1.2. Determine method signatures for handling file paths relative to BIN_PATH.

2. Implementation Phase

• 2.1. Setup project environment.
  • 2.1.1. Create a new Python project and setup virtual environment.
  • 2.1.2. Define BIN_PATH in a configuration file or as an environment variable.
• 2.2. Implement the FileSystem class.
  • 2.2.1. Implement method for resolving paths relative to BIN_PATH.
  • 2.2.2. Implement file reading functionality.
  • 2.2.3. Implement file writing functionality.
  • 2.2.4. Implement additional file management methods as identified in 1.1.1.
• 2.3. Error handling and validation.
  • 2.3.1. Implement error handling for file operations to prevent crashes.
  • 2.3.2. Validate file paths to prevent data loss.
• 2.4. Document the FileSystem class.
  • 2.4.1. Write docstrings for each method, detailing parameters, return values, and exceptions.
  • 2.4.2. Create a README file with setup instructions and examples of how to use the FileSystem class.

3. Testing Phase

• 3.1. Write unit tests for the FileSystem class.
  • 3.1.1. Test path resolution relative to BIN_PATH.
  • 3.1.2. Test file reading functionality.
  • 3.1.3. Test file writing functionality.
  • 3.1.4. Test error handling and path validation.
• 3.2. Perform integration testing.
  • 3.2.1. Test the FileSystem class with mock file operations.
  • 3.2.2. Ensure compatibility with the overall project environment.
• 3.3. Code review and refactoring.
  • 3.3.1. Conduct a code review to ensure code quality and adherence to best practices.
  • 3.3.2. Refactor code as necessary based on feedback.

Originally posted by @Josephrp in #10 (comment)

Ensure `Doctor.bat` Verifies `ml-agents` Installation

Description

The Doctor.bat script currently does not check if ml-agents is installed on the system. This can lead to runtime errors for users who haven't installed ml-agents. To improve the user experience and catch this issue early, we should include a check for ml-agents installation within the Doctor.bat script.

Expected Behavior

When running Doctor.bat, the script should:

• Check if ml-agents is installed.
• Provide feedback to the user about the presence of ml-agents.
• Offer guidance on how to install ml-agents if it is not found.

Current Behavior

The script executes without verifying the installation of ml-agents, which is a prerequisite for our project.

Possible Solution

Implement a check within Doctor.bat that looks for ml-agents in the system's PATH or in the expected installation directories. If ml-agents is not found, the script should inform the user and provide installation instructions.

Steps to Reproduce

1. Run Doctor.bat on a system without ml-agents installed.
2. Observe that there is no check or message regarding ml-agents.

Additional Context

This check is crucial for users who are setting up the project for the first time and might not be aware of all the dependencies.

---

Feel free to adjust the content as needed before submitting it to your project's GitHub repository.

Implement Minimal FileSystem Class for DialogosEngine

Summary

We need a minimal FileSystem class that manages file operations relative to the BIN_PATH, which will serve as the root for our file system.

Details

• The class should provide methods for reading, writing, and managing files.
• It should handle paths relative to the BIN_PATH.
• Include error handling for file operations to prevent crashes and data loss.

Acceptance Criteria

• The FileSystem class can perform basic file operations.
• File paths are correctly resolved relative to the BIN_PATH.
• The class is robust and includes unit tests and documentation.

Implement Basic Unit Tests for SocraticAgent and Lexer Classes

Implement Basic Unit Tests for SocraticAgent and Lexer Classes

Objective:

To ensure the reliability and correctness of the SocraticAgent and Lexer classes within the Dialogos project, we aim to implement a suite of basic unit tests.

Tasks:

• Identify key functionalities and methods within the SocraticAgent class that require testing.
• Develop unit tests for the Initialize, OnEpisodeBegin, CollectObservations, and OnActionReceived methods of the SocraticAgent.
• Identify critical operations within the Lexer class, such as text transformation and numerical representation.
• Create unit tests for the Transform, CalculateWhitespace, CalculateVariance, and CreateQuaternion methods of the Lexer.
• Ensure that tests cover a range of input scenarios, including edge cases.
• Integrate tests with Unity Test Runner for automated testing within the Unity Editor.
• Document test cases and expected outcomes to facilitate maintenance and future development.

Acceptance Criteria:

• All unit tests should pass successfully.
• Tests should provide comprehensive coverage of the identified methods.
• The testing framework should be easily extendable for future test cases.

This ticket will serve as the foundation for maintaining high code quality and facilitating future feature development with confidence.

Enhance Script Interpreter with Print/Echo Command

Summary

We need to implement a print or echo command in our script interpreter to allow scripts to output messages directly to the console.

Details

• The command should be able to handle string arguments and print them to the console.
• Ensure the command is properly parsed and executed within the script interpreter.
• Include error handling to manage cases where the command is used incorrectly.

Acceptance Criteria

• A print or echo command is available in the script interpreter.
• The command outputs the expected string to the console.
• Proper documentation and examples are provided.

Develop Custom Logging System

Summary

Create a custom logging system that can categorize and output logs at different levels such as INFO, DEBUG, WARN, and ERROR.

Details

• The system should support various log levels and provide clear formatting for each.
• Include timestamps and other relevant information in each log entry.
• Ensure the logging system is easily integrable with existing and future modules.

Acceptance Criteria

• The logging system is capable of handling multiple log levels.
• Logs are formatted clearly and contain all necessary information.
• The system has been tested and documented.

Benchmarking Lexer Against Hugging Face Transformer

Benchmarking Lexer Against Hugging Face Transformer

Objective:

To evaluate the performance and effectiveness of our custom Lexer in comparison to the Hugging Face transformer, we will create a benchmark that measures speed, memory usage, and the quality of context representation.

Tasks:

• Set up a Python environment with the necessary Hugging Face transformers library and dependencies.
• Develop a Python script to tokenize and vectorize text using the Hugging Face transformer.
• Include additional context calculations in the Python script, such as entropy, whitespace, variance, etc.
• Create a mechanism within Unity to call the Python script and capture its output.
• Design the benchmark to measure the processing time, output size, and context quality for both systems.
• Ensure the benchmark tests are repeatable and consistent across multiple runs.
• Document the benchmark process, including setup, execution, and result interpretation.

Acceptance Criteria:

• The benchmark should accurately measure and compare the performance of our Lexer and the Hugging Face transformer.
• Results should highlight the strengths and weaknesses of each approach in terms of speed, efficiency, and context representation.
• The benchmarking process should be well-documented and easily reproducible for future testing and development.

This ticket will guide the development of a comprehensive benchmarking suite that will inform our decision-making process regarding text processing tools within our project.

Implement 'DEV BuiltIn Command' for Local ML-Agents Installation

Issue Title: Implement 'DEV BuiltIn Command' for Local ML-Agents Installation

Description

The Dialogos project requires a new built-in command within Unity to streamline the local installation of ML-Agents. This command should invoke our run.py script, which is responsible for setting up ML-Agents in the development environment.

Requirements:

• Command Name: DEV BuiltIn Command
• Functionality: The command should execute the run.py script from within Unity's context.
• Outcome: Successful execution of the script will install ML-Agents locally without manual intervention.
• Integration: The new command will be integrated into the .unityboot file, which is auto-generated during the Unity boot process.

Acceptance Criteria:

1. The DEV BuiltIn Command is accessible within Unity's command palette.
2. Running the command executes the run.py script successfully.
3. ML-Agents is installed locally, and the environment is ready for ML development.
4. The .unityboot file invokes the DEV BuiltIn Command as part of its initialization sequence.

Additional Context:

This feature is intended to simplify the setup process for developers working on the Dialogos project under the NaXzyu GitHub organization. By automating the installation of ML-Agents, we aim to reduce setup time and potential configuration errors.

Refactor TerminalCommand to Utilize SessionManager for Static Terminal Property

Overview

The current implementation of the TerminalCommand class uses a static property to reference the terminal instance. This approach can lead to issues with flexibility and testability. To improve the design, we propose refactoring the TerminalCommand class to use the SessionManager for managing terminal instances.

Goals

• Decouple the TerminalCommand class from a static terminal instance.
• Implement the SessionManager to handle terminal sessions.
• Enhance the maintainability and testability of the terminal management system.

Tasks

• Create a new SessionManager class that will manage terminal instances.
• Replace the static terminal property in the TerminalCommand class with a method to retrieve the current terminal session from the SessionManager.
• Update all references to the static terminal property throughout the codebase.
• Ensure that existing functionality is preserved and that all unit tests pass.
• Document the changes and update any relevant documentation.

Acceptance Criteria

• The TerminalCommand class no longer uses a static property for the terminal instance.
• The SessionManager is fully implemented and integrated with the TerminalCommand class.
• All existing tests pass, and new tests are added to cover the changes.
• The system behaves as expected, with no regressions in functionality.

Please review the proposed changes and provide feedback or approval to proceed with the implementation.

Implement Scriptable Build Pipeline and CommandTerminal Build Commands

Background

To streamline our game development process, we need to implement a scriptable build pipeline that allows for automated builds into specified directories. This will enable us to build the game from within the game's runtime environment or through command-line arguments.

Feature Request

• Develop a scriptable build pipeline that can be triggered via Unity's CommandTerminal.Shell.
• Create a new CommandTerminal command that accepts a directory path as an argument and initiates the build process to that path.

Use Case

This feature will be particularly useful for automating the build process for different environments or for creating builds that include user-generated content. It will also allow developers to initiate builds directly from the game's command terminal, enhancing productivity and flexibility.

Expected Outcome

The successful implementation of this feature will simplify the build process, making it more efficient and less error-prone. It will also provide a foundation for further automation and integration with other systems in the future.

Additional Notes

• Ensure compatibility with existing CommandTerminal.Shell syntax and functionality.
• Include error handling for invalid paths or build failures.
• Document the new build command and its usage for team reference.

Implementation of OS Emulation Features in Unity Project

Overview

This ticket outlines the implementation of various operating system (OS) emulation features within our Unity project. The goal is to create a robust emulation that replicates the functionalities of a real OS environment.

Key Components to Implement

• File System: A virtual file system to handle files and directories, including CRUD operations, copying, moving, and permissions.

• Process Management: A system for process creation, execution, and termination, including process states, scheduling, and IPC.

• Memory Management: Memory allocation and management system, incorporating virtual memory and paging.

• Input/Output System: Management of I/O operations and device drivers for different device types.

• User Interface: A GUI or CLI for user interaction with the emulated OS.

• Networking: Networking capabilities for communication over networks with support for various protocols.

• Security: Security measures including user authentication, authorization, encryption, and secure data storage.

• System Utilities: Utilities for system monitoring, configuration, and maintenance.

• Application Support: Compatibility with applications through necessary APIs and runtime environments.

• Hardware Abstraction: An abstraction layer for interacting with the underlying hardware or host OS.

Considerations

• The scope of emulation will depend on the intended use, such as software development, testing, education, or legacy system support.
• Emulating an OS is a complex task that requires a deep understanding of OS architecture and low-level programming.

Testing

• Ensure all changes are thoroughly tested before merging.
• Document any new dependencies or setup steps required for testing.

Collaboration

• Changes should be pushed to a feature branch for review.
• Keep commits small and focused to simplify code reviews and troubleshooting.

Please refer to the project's contribution guidelines for more details on submitting pull requests.

---

• 1. Implement a Virtual File System to manage files and directories.
• 2. Develop Process Management for process creation, execution, and termination.
• 3. Create a Memory Management system, including virtual memory and paging.
• 4. Handle Input/Output Operations and manage device drivers.
• 5. Design a User Interface (GUI or CLI) for user interactions.
• 6. Establish Networking capabilities for communication over networks.
• 7. Set up Security measures, including user authentication and data encryption.
• 8. Provide System Utilities for monitoring, configuration, and maintenance.
• 9. Ensure Application Support through necessary APIs and runtime environments.
• 10. Build a Hardware Abstraction Layer for interacting with the underlying hardware or host OS.

Dialogos Project: Enhancing Language Learning Through Interactive Storytelling

Dialogos Project: Enhancing Language Learning Through Interactive Storytelling

Overview

We're developing an innovative language model called Dialogos, which aims to transform the way users interact with AI. The concept is rooted in the Greek tradition of "διάλογος," reflecting a deep exchange of ideas and knowledge through conversation.

Objective

The goal is to integrate Dialogos with Unity to create an immersive language learning experience. We envision a platform where users can learn languages through engaging, story-driven adventures, akin to a modern-day version of a MUD (Multi-User Dungeon) but focused on storytelling rather than dungeons.

Key Features

• Interactive Adventures: Users will navigate through branching narratives, making choices that influence the story's outcome.
• Data Collection: These stories will serve as a means to collect linguistic data, which will be used to train and improve the Dialogos model.
• Engagement: By actively participating in the story, users will contribute to a rich dataset, reflecting a wide range of language use.

Call to Action

We need to develop compelling narratives, design a user-friendly interface, and implement data analysis mechanisms. This project is not just about learning a language; it's about crafting an odyssey where users can explore new linguistic horizons in a fun and creative way.

Setup and Configuration of Automated Testing for Dialogos Unity Project

Objective:

The goal of this ticket is to establish a robust automated testing framework for the Dialogos Unity project that encompasses both editor and play mode tests. This will ensure that our codebase maintains high quality and stability as we continue to integrate new features and functionalities.

Tasks:

• Research and select appropriate testing frameworks compatible with Unity.
• Create a new test suite within the Unity Test Runner for editor and play mode tests.
• Develop initial test cases to cover critical functionalities of the Dialogos Engine.
• Configure the Unity Test Runner to execute both editor and play mode tests.
• Set up GitHub Actions workflow to automate the running of tests on every push and pull request.
• Document the testing procedures and add instructions to the README for future contributors.

Acceptance Criteria:

• A complete suite of editor and play mode tests is implemented and documented.
• GitHub Actions workflow is configured to run the test suite automatically.
• All tests pass successfully, and any failures are reported clearly.
• Documentation is updated to guide contributors on how to write and run tests.

Notes:

• Ensure that the testing framework chosen does not introduce significant overhead or complexity.
• Consider the potential need for mock objects or services to simulate gameplay scenarios.