1.0.78 (#83)

* 1.0.78

* Create project_info.md

* 1.0.78

* fixes

* 1.0.61

* Update IterativePatchUtilTest.kt

docs/project_info.md

@@ -0,0 +1,209 @@
+# Software Project Formalization and Documentation Questionnaire
+
+## General Information
+
+1. **Project Name:**
+   Skyenet LLM Agent Platform
+
+2. **Project Description:**
+   The Skyenet LLM Agent Platform is designed to facilitate the integration and utilization of large language models (LLMs) in various applications. It provides a framework for managing LLM interactions, handling user inputs, and displaying dynamic content.
+
+3. **Project Objectives:**
+    * To create a robust and flexible platform that supports real-time LLM interactions.
+    * To provide a seamless user experience with dynamic content updates.
+    * To integrate various backend processes and user interactions using LLMs.
+
+4. **Target Audience:**
+   Developers building applications that leverage large language models for tasks such as coding assistance, image generation, text-to-speech conversion, and more.
+
+## Scope and Deliverables
+
+1. **Assumptions and Context:**
+    * What assumptions are being made about the project?
+        * The system will be used in applications that require real-time LLM interactions.
+        * Users will have access to modern LLM models and necessary computational resources.
+    * What is the context in which this project is being developed?
+        * The project is being developed to enhance user interaction in applications by providing a dynamic and responsive LLM-based platform.
+    * What problem is this project aiming to solve?
+        * The project aims to solve the problem of integrating and utilizing large language models in applications, by providing a flexible and robust LLM agent platform.
+        * The project aims to solve the problem of static web pages that require full page reloads for updates, by
+          providing a real-time, interactive UI framework.
+
+2. **Scope:**
+   The project includes the development of an LLM agent platform that supports real-time interactions using large language models, dynamic content updates, and integration with various backend processes.
+
+3. **Deliverables:**
+    * An LLM-based agent platform.
+    * Documentation for developers.
+    * Example implementations and usage guides.
+    * Integration with backend processes.
+
+4. **Out of Scope:**
+    * Development of LLM models.
+    * Support for outdated computational resources that cannot handle modern LLMs.
+
+5. **Use Case Details:**
+    * **Coding assistance**: Generate and execute code snippets based on natural language instructions.
+    * **Image generation**: Transform textual descriptions into images using image generation models.
+    * **Text-to-speech conversion**: Convert text into speech using text-to-speech models.
+    * **Interactive discussions**: Facilitate user interactions and collect feedback to refine responses.
+
+## Developer Documentation
+
+1. **Code Repository:**
+   The code repository will be hosted on GitHub at https://github.com/your-repo/skyenet-llm-agent-platform
+
+    * Repository URL:
+    * Branching strategy:
+    * Contribution guidelines:
+
+2. **Development Setup:**
+    * Clone the repository from GitHub.
+    * Install the required dependencies using the provided setup script.
+    * Follow the development environment setup guide in the repository's README file.
+
+3. **Contribution Guidelines:**
+    * Follow the coding standards and best practices outlined in the CONTRIBUTING.md file.
+    * Submit pull requests for code reviews before merging changes.
+    * Write unit tests for new features and bug fixes.
+
+4. **API Documentation:**
+   API documentation can be found in the docs/api directory of the repository.
+
+5. **Coding Standards:**
+   What coding standards or best practices should be followed?
+    * Follow the Kotlin coding conventions.
+    * Use meaningful variable and function names.
+    * Write clear and concise comments.
+      Are there any specific linting or formatting tools to be used?
+    * Use ktlint for linting and code formatting.
+      Are there any version control guidelines?
+    * Use Git for version control.
+      Are there any specific branch naming conventions or commit message guidelines?
+    * Use feature/branch-name for feature branches.
+    * Use fix/branch-name for bug fix branches.
+    * Follow the commit message guidelines outlined in the CONTRIBUTING.md file.
+
+## Architecture and Design
+
+1. **System Architecture:**
+    * Overview of the system architecture:
+      The Skyenet LLM Agent Platform is designed with a modular architecture to support real-time, interactive applications leveraging large language models. The core components include the LLM manager, session management, and dynamic content rendering. The system leverages LLMs for real-time interaction between the client and server, ensuring low latency and high
+      responsiveness. The architecture is divided into several layers: the presentation layer (UI components), the
+      application layer (session and task management), and the data layer (storage and retrieval of user data and
+      settings).
+
+    * Diagrams (if any):
+      ![System Architecture Diagram](path/to/diagram.png)  // Add a path to the actual diagram if available
+
+2. **Design Patterns:**
+    * What design patterns are used?
+      The Skyenet LLM Agent Platform employs several design patterns to ensure a robust and maintainable codebase:
+
+ **Observer Pattern**: Used in the LLM manager to handle real-time updates and notifications.
+ **Factory Pattern**: Utilized for creating instances of various components like session tasks and UI elements.
+ **Singleton Pattern**: Ensures a single instance of core managers like `ApplicationServices`
+    - **Observer Pattern**: Used in the WebSocket manager to handle real-time updates and notifications.
+    - **Factory Pattern**: Utilized for creating instances of various components like session tasks and UI elements.
+    - **Singleton Pattern**: Ensures a single instance of core managers like `ApplicationServices`
+      and `SocketManagerBase`.
+ **Strategy Pattern**: Allows for flexible implementation of different retry mechanisms in the `Retryable` class.
+ **Decorator Pattern**: Used to extend the functionality of UI components dynamically.
+    - **Strategy Pattern**: Allows for flexible implementation of different retry mechanisms in the `Retryable` class.
+    - **Decorator Pattern**: Used to extend the functionality of UI components dynamically.
+
+    * Why were they chosen?
+      These design patterns were chosen to promote code reusability, flexibility, and separation of concerns. The
+      Observer Pattern is ideal for real-time LLM interaction scenarios, while the Factory Pattern simplifies the creation
+      of complex objects. The Singleton Pattern ensures efficient resource management, and the Strategy Pattern allows
+      for easy customization of retry logic. The Decorator Pattern enables dynamic enhancement of UI components without
+      modifying their core functionality.
+
+3. **Technology Stack:**
+    * List of technologies and frameworks used:
+
+    - **Frontend**: HTML, CSS, JavaScript, and Kotlin for the UI components and LLM interactions.
+    - **Backend**: Kotlin for server-side logic, leveraging Ktor for building asynchronous servers and managing LLM interactions.
+    - **LLMs**: Used for real-time interaction between the client and server.
+    - **Database**: HSQLDB for usage tracking, data storage, and managing LLM interactions.
+ **Cloud Services**: AWS S3 for file storage, AWS KMS for encryption.
+ **CI/CD**: GitHub Actions for continuous integration and deployment, Docker for containerization.
+    - **Cloud Services**: AWS S3 for file storage, AWS KMS for encryption.
+    - **CI/CD**: GitHub Actions for continuous integration and deployment, Docker for containerization.
+
+    * Reasons for choosing these technologies:
+      The chosen technologies and frameworks provide a balance of performance, scalability, and developer productivity. Kotlin is used for both frontend and backend development to ensure consistency and leverage its modern language features. Ktor is selected for its lightweight and asynchronous capabilities, making it suitable for real-time LLM interactions. LLMs are essential for maintaining low-latency communication. HSQLDB is chosen for its
+      simplicity and ease of integration. AWS services are utilized for their reliability, security, and scalability.
+      GitHub Actions and Docker streamline the CI/CD process, ensuring efficient and reliable deployments.
+
+## Components and Modules
+
+1. **Component Overview:**
+    * **LLMManagerBase**: Manages LLM interactions, message queuing, and broadcasting. It handles the core LLM functionality, ensuring reliable communication between the client and server.
+    * **ApplicationInterface**: Provides methods to create interactive HTML elements and manage tasks. It acts as a
+      bridge between the task management logic and the LLM communication layer.
+    * **SessionTask**: Represents a task that can display progress and messages. It allows for dynamic updates to the UI
+      as tasks progress.
+    * **TabbedDisplay**: Manages a tabbed interface for displaying content. It supports adding, updating, and rendering
+      tabs dynamically.
+    * **Retryable**: Extends `TabbedDisplay` to add a retry mechanism for tasks. It allows for re-running a block of
+      code and capturing the new output in a new tab.
+    * **AgentPatterns**: Provides utility functions for displaying content in tabs. It helps in organizing and rendering
+      content efficiently.
+    * **Discussable**: Facilitates interactive discussions with users, allowing for feedback and revisions. It manages
+      user interactions and refines responses based on feedback.
+    * **UserSettingsManager**: Manages user settings, including loading and saving settings to disk. It ensures that
+      user preferences are maintained across sessions.
+    * **ClientManager**: Manages API clients, including creating and caching clients for sessions and users. It handles
+      the lifecycle of API clients and ensures efficient resource usage.
+    * **HSQLUsageManager**: Manages usage tracking using an HSQL database. It tracks resource usage and provides
+      summaries for monitoring and billing purposes.
+    * **AuthorizationManager**: Manages user authorization, checking if a user is authorized for specific operations. It
+      enforces access control policies.
+    * **AuthenticationManager**: Manages user authentication, including storing and retrieving users based on access
+      tokens. It ensures secure access to the system.
+    * **DataStorage**: Manages data storage, including storing and retrieving messages, sessions, and other data. It
+      provides a persistent storage layer for the application.
+    * **AwsPlatform**: Provides integration with AWS services, including S3 for file storage and KMS for encryption. It
+      leverages cloud services for scalability and security.
+
+2. **Inter-component Communication:**
+    * **LLM Communication**: `LLMManagerBase` handles the LLM interactions and message broadcasting. It
+      interacts with `ApplicationInterface` to send and receive messages.
+    * **Task Management**: `ApplicationInterface` creates and manages `SessionTask` instances. These tasks
+      use `TabbedDisplay` and `Retryable` to display content and handle retries.
+    * **User Interaction**: `Discussable` manages user interactions and collects feedback. It works with `SessionTask`
+      to update the UI based on user input.
+    * **Data Storage and Retrieval**: `DataStorage` handles the storage and retrieval of data. It interacts
+      with `UserSettingsManager`, `ClientManager`, and `HSQLUsageManager` to manage user settings, API clients, and
+      usage tracking.
+    * **Authorization and Authentication**: `AuthorizationManager` and `AuthenticationManager` enforce security
+      policies. They interact with other components to ensure secure access and operations.
+    * **Cloud Integration**: `AwsPlatform` provides cloud services for storage and encryption. It integrates
+      with `DataStorage` and other components to leverage AWS services.
+
+## Testing and Quality Assurance
+
+1. **Testing Strategy:**
+   What is the overall testing strategy?
+    * The testing strategy includes unit testing, integration testing, system testing, and acceptance testing.
+      What types of testing will be performed (unit, integration, system, acceptance)?
+    * **Unit Testing**: Testing individual components and functions.
+    * **Integration Testing**: Testing interactions between components.
+    * **System Testing**: Testing the entire system as a whole.
+    * **Acceptance Testing**: Testing the system against user requirements.
+
+2. **Test Cases:**
+   Test cases will be documented in the docs/test-cases directory of the repository.
+
+3. **CI/CD Pipeline:**
+   What is the CI/CD pipeline setup?
+    * The CI/CD pipeline includes automated testing, code quality checks, and deployment processes.
+      What tools and services are used for CI/CD?
+    * The pipeline uses GitHub Actions for automation, Docker for containerization, and AWS for deployment.
+
+4. **Code Reviews:**
+   What is the process for code reviews?
+    * Code reviews are conducted through pull requests on GitHub.
+      Who is responsible for code reviews?
+    * The development team is responsible for reviewing each other's code.

docs/project_info_template.md

@@ -0,0 +1,138 @@
+# Software Project Formalization and Documentation Questionnaire
+
+## General Information
+
+1. **Project Name:**
+   What is the name of the project?
+
+2. **Project Description:**
+   Provide a brief description of the project.
+
+3. **Project Objectives:**
+   What are the main objectives of the project?
+
+4. **Target Audience:**
+   Who are the intended users of the project?
+
+5. **Stakeholders:**
+   Who are the key stakeholders involved in the project?
+
+6. **Assumptions and Context:**
+    - What assumptions are being made about the project?
+    - What is the context in which this project is being developed?
+    - What problem is this project aiming to solve?
+
+## Scope and Deliverables
+
+1. **Scope:**
+   What is the scope of the project?
+
+2. **Deliverables:**
+   What are the key deliverables of the project?
+
+3. **Out of Scope:**
+   What is explicitly out of scope for the project?
+
+4. **Use Case Details:**
+    - What are the primary use cases for the project?
+    - Provide detailed descriptions of each use case.
+
+5. **Comparative Product Analysis:**
+    - Are there existing products that solve a similar problem?
+    - How does this project compare to those products?
+
+## Timeline
+
+1. **Start Date:**
+   When is the project starting?
+
+2. **End Date:**
+   When is the project expected to be completed?
+
+3. **Key Dates:**
+   Are there any key dates or deadlines that need to be met?
+
+4. **Milestones:**
+   List the major milestones and their expected completion dates.
+
+## Risks and Assumptions
+
+1. **Risks:**
+   Identify potential risks and their mitigation strategies.
+
+2. **Assumptions:**
+    - List any assumptions made during the planning of the project.
+
+## Project Closure
+
+1. **Closure Criteria:**
+    - What are the criteria for project closure?
+    - How will success be measured?
+
+2. **Post-Implementation Review:**
+    - Will there be a post-implementation review?
+    - What will be the focus of this review?
+
+3. **Lessons Learned:**
+   How will lessons learned be documented and shared?
+
+## Developer Documentation
+
+1. **Code Repository:**
+   Where will the code repository be hosted?
+
+2. **Development Setup:**
+   What are the steps to set up the development environment?
+
+3. **Contribution Guidelines:**
+   What are the guidelines for contributing to the project?
+
+4. **API Documentation:**
+   Where can developers find the API documentation?
+
+5. **Coding Standards:**
+   What coding standards or best practices should be followed?
+   Are there any specific linting or formatting tools to be used?
+   Are there any version control guidelines?
+   Are there any specific branch naming conventions or commit message guidelines?
+
+6. **Architectural Perspectives:**
+    - What are the different architectural perspectives of the project?
+    - Provide diagrams and descriptions for each perspective (e.g., logical, physical, deployment, etc.).
+    - What coding standards or best practices should be followed?
+    - Are there any specific linting or formatting tools to be used?
+    - Are there any version control guidelines?
+    - Are there any specific branch naming conventions or commit message guidelines?
+
+## Testing and Quality Assurance
+
+1. **Testing Strategy:**
+    - What is the overall testing strategy?
+    - What types of testing will be performed (unit, integration, system, acceptance)?
+
+2. **Test Cases:**
+   Where are the test cases documented?
+
+3. **CI/CD Pipeline:**
+    - What is the CI/CD pipeline setup?
+    - What tools and services are used for CI/CD?
+
+4. **Code Reviews:**
+    - What is the process for code reviews?
+    - Who is responsible for code reviews?
+
+## Maintenance and Support
+
+1. **Maintenance Plan:**
+    - What is the plan for ongoing maintenance?
+    - How will updates and patches be handled?
+
+2. **Support Plan:**
+    - What is the support plan post-deployment?
+    - Who will provide support and how can they be contacted?
+
+3. **Documentation:**
+    - What user documentation will be provided?
+    - Where can users find help and support documentation?
+    - What coding standards or best practices should be followed?
+    - List any assumptions made during the planning of the project.