DoMax

Started working on restructuring the app to use domain-driven development patterns. Also started planning on how docs are going to be made (current solution - a Jekyll-built webpage for easy docs' changes using markdown).
The app needs a lot of testing to make sure everything works as it did without major changes in functionality, since API isn't going to be changed too much over the course of following week. Another priority - ensuring the app looks pretty much the same besides feeling like a completely different project when looking at its codebase.
I really hope I can pull these advancements off and make the app not only work well, but also be nice to code by getting rid of its monolithic design.

After a long break from coding, I'm back at it again and got some nice QoL updates for EchoTuner:
App now limits input fields so that user doesn't have to stare at an error pop up when input prompts are too long (since limits can now be seen in the app, it adds clarity).
Fixed asynchronous login bug, where the login button acted as a popup - first gathering info about itself from the API (OAuth login link) and only then performing an action - Safari and WebView systems don't like such behaviour and often end up blocking it. Havent tested it fully, but conceptually it should work.
Made so that fewer API calls are being done resulting in less abuse and lighter systems.
Further plans:
- Nice documentation.
- Nice app structure tat mimics API's.
- API refactor with more clarity.
- API keys for external usage.

EchoTuner has finally reached its second beta release! With all the promises done and ready to experience, it's more convenient than ever before! With improved account handling and cross-device support for shared mode users (normal mode hasn't been tested yet, but I'm making huge progress in doing so - making developer-focused updates, which include better documentation, structure and moddability), you can use it at full capability. Even the limits have been increased, since I'm able to provide users with a bit more than initially thought I could (5 daily playlists is better than 3!)
Can't wait for you all to try it out!

EchoTuner is getting really close to its second beta release! With full support for cross-device compatibility in both shared AND normal modes, slight UI tweaks, full implementation of Coming Soon features in the app and a massive refactor in how the full-stack app is structured, can be used (API usage will depend on proper REST principles from now on) and how the database looks like, this is nothing but a dream for both users and developers wanting to explore EchoTuner and using it free of charge.

Even though EchoTuner has been shipped, work on it continues. I've got big plans for an upcoming Google SSO login feature so that even demo mode users can enjoy cross-device, free of charge! I've got a lot of work to do and will probably spend a quite a lot of time on this alone, as well as a massive refactor for both the API and the app to use a domain-driven approach of structure and architecture. But I really hope that by the end of this month everyone will be able to use the updated, secure and advanced implementation of EchoTuner with hardly any limitations noticable!

After spending almost 130h, fixing countless bugs, facing issues and having to bypass things that don't depend on me, I've come to the conclusion that Spotify is one of the least friendly platforms for developers.
They've got the worst support I've come across. Despite having ready-to-use OAuth clients, making such critical changes to usage policy this late is really awful on their part. For anyone reading this having similar ideas, either don't start or prepare for many inconveniences.
However, EchoTuner won't stop there! By implementing a feature where all the Spotify queries between API and their servers happen using only the OAuth client owner's access token, I made sure the whole full-stack app works fine and is ready for deployment. With only a handful of things missing (and a massive refactor needed) EchoTuner will most likely be available to use sooner than 24h after publishing this devlog.
I'm very glad how the journey turned out. I've learned a lot (and could note many places for improvements), and couldn't be happier. It's true that I'm very irritated about Spotify almost leading me to give up and preventing this whole idea from becoming true, but who am I to put this project down? EchoTuner will continue until anyone can experience it, with many improvements to come!

Today has marked a lot of time wasted on useless improvements that had a chance of working but lead to me failing to refactor the whole codebase 2 times with significant API and logic changes and overengineering on working things, after which I kind of gave up on these major changes and decided to take everything slow. The current container builds work, but the codebase is a mess. Looking forward to improving it with dedicated routing, cutting down main.py size in half and structurizing database operations better.
I'm deciding on whether or not to remove the refinement feature, since the refinements are inaccurate for the most part and hard to manage in code, but I haven't decided on that yet. Tomorrow I will.
Today wasn't the most successful day, but lead to having 7 additional hours appended to this project, which, in my mind, is quite good.

Since the server machine is still having issues from being able to launch my API and web app, I'm continuing work on the API, implementing further architectural changes, such as migration to ORM, embedding caching and so on.
It's very sad that launch has been delayed so many times, but I'm not giving up, even after so many roadblocks EchoTuner has faced. It must be launched, but now it just depends on time. If I'm lucky, this month's the charm. If not, I hope that summer will let me make a functional demo for the whole community and beyond test out, providing suggestions on further improvements.
For the next few hours of coding, I will be focusing on improving both the app and the API to be more enterprise-like, with no place for human error (I'm looking at you, hardcoded database queries!) and/or vulnerabilities. Wish me luck!

Implemented better CORS handling.
Implemented better validation for prompts, errors, etc.
Fixed API stalling issue, where an asynchronous task was being run incorrectly (playlist draft service).
Implemented IP rate limiting.
Made Uvicorn exclude, rather than include manual reload directories for easier management.
Subtle formatting changes.
Incremented version minor number.

Made some bugfixes for EchoTuner.
Finally resolved database sharing question - now, by default, it's saved in storage/echotuner.db and by taking docker-compose.yml sample file from EchoTuner's GitHub you can easily check out how mounted storage works, having the ability to share your database across different containers and not having to worry about container deletion - database will be preserved in system files!
Switched to envsubst, providing a template of javascript file that holds environment values for web app, passing required variables through the environment instead of hardcoding them into the entrypoint shell script.

Implemented GitHub Actions and published containers onto the GitHub Container Registry for anyone to use!
And fixed a bug with GitHub actions where the Flutter web app couldn't get any environment variables without a provided file (that bakes the variables into the app). Now it supports environment through an external javascript file that gets updated with the latest variables everytime you run the container, not even needing to include a .env file in the pubspec.yaml anymore! It's considered some subtle hacking-around the Flutter's system (since it builds static content) and requires a deprecated library as fully supported alternatives don't exist yet. But it finally works and is ready for deployment!

Made a lot of changed over the past few hours:
- Fixed Docker composing.
- Implemented security features (body-based request philosophy, better prompt validator).
- Updated endpoint naming scheme.
- Implemented docs.
- Implemented better cleanup logic.
- Refactored written code.
- Changed logging to debug for unnecessary log protection.
- Updated Flutter packages' versions.

And probably more I don't even remember. This project is ready for production and demo release, I just have to get a way to host the ecosystem. Since it's done through Docker containers, in case you wanted to try it out early and without limitations, you can do so by visiting the Github repository of Echotuner and following quick startup guides for an easy setup (Github container registry entry coming soon for an even easier deployment). Don't mind Dart errors - they're there just because JSON serializable code hasn't been generated yet, which will be fixed during the Docker container build.

Moved all api endpoint methods to separate files in api/endpoints/.
Began making modular AI model setup.
Next steps (since AI models implementation took a bit of a turn):
- Finish refactoring the API and the app (their code).
- Finish implementing the modularity of the api providers.
- Refactor the API endpoints.
- Release the app (due to recent roadblocks of Spotify API usage and other implementation bugs it's been delayed a bit. Expecting to release the demo in 1-3 days).
- Make better docs.

Finally implemented the new demo mode for the app and it's ready for a release!
Next steps:
- Demo release!! (Docker, cloud models' integration)
- Refactoring.
- Docs.

Started working on demo account creation and app handling of them for the release.
Due to Spotify's new OAuth client policies, an app like this will never be able to be launched in full scale, as described here:
https://developer.spotify.com/documentation/web-api/concepts/quota-modes

But that didn't let me down as I will be implementing a new demo-mode for users to experience and and provide tools for them to run the app themselves under their administration if they wish to use it without limits and using their OAuth clients.
Don't know what pushed Spotify into disrupting the creation of such services by pulling the plug on personal quota updates on OAuth clients, but I won't let such roadblock stop me from maintaining this project!

Implemented a better integration with more AI providers other than Ollama.
Added a singleton pattern for services which are responsible for themselves
Made more services each doing their own thing.
Made a lot of security improvements (restriction of certain endpoints and more).
Implemented reusable templates, systems and services for the app.
Made a custom logger more useful/usable.
Reworked the UI and UX a bit.
Made improvements to app's stability when dealing with personality and playlist adjustments (lauto-saving, auto-reload, deletion and editing of playlist as soon as it gets generated and more).
Updated READMEs to reflect the app better.
Next steps:
- Docker image build support
- Login security enhancements
- Hosting
- Publishing

Added a sound system for reference, might expand it later to account for physics and collisions in a world.
Implemented a better and less-repetitive init point.
Updated cleanup for engine core accounting for audio.

Implemented the ability to use more models and providers, not only Ollama ones.
Added silent refresh in personality screen, library is still waiting for such an upgrade.
I'm yet to check if everything works, but tomorrow will be the day I get to do so and (hopefully) have the first, fully working release version of this project! Very excited for it
Only minor UI refreshments remain and maybe some code restructuring for it to look nicer (I don't like the idea of files being 1000+ lines of code long, especially in such a simple project).
And on the backend side of things, tests must be made to ensure everything is secure, convenient and usable with no weird errors occuring. It's going to be a long day or two!

Implemented a personality edit service with a slight tweak of how UI works and feels.
Also added some branding in the login screen, as well as an icon for the EchoTuner app.
Known issues:
- Some UI elements aren't appealing or functional.
- Screens don't refresh at times.
- A lot of leftover/garbage/ugly code.
- Lack of documentation with the latest changes.
- Security issues as the latest version is debug-oriented.
- AI isn't trained properly yet.

Aside from these issues this service is completely functional and you can start using it locally with an official demo coming soon!

Finally! The app (and the API) is ready for production!
I have addressed the issues they both had and fixed them leaving only the app with a minor design flaw on PC builds (info messages are too high up as they've been adjusted for phones and haven't seen a platform-independent way of handling this) and a READMEs update with the latest changes of this project.
The app works just as you would expect with only one core feature missing (personality adjustments) (other working things are yet to document).
After implementing it and fixing the design flaw mentioned above, I'll move onto hosting this for you to experience!

Added the ability to add generated playlists to Spotify and refine existing ones.
Known issues:
- Refinements seem infinite after a playlist has been added to Spotify. It should be known to the API how many times has a user refined generated playlists before addition and that number should stay the same across the refresh window.
- No option to update existing playlists. A user can only add a new one from the old one's refinement.
- Information messages don't look good and aren't of one design.
- Refreshing the Spotify playlists menu brings a user back to the drafts.
- Drafts are stored on device, but they should be stored per-account in the server with a deletion span until they've been added to Spotify.

Next step would be to resolve these issues and enhance/check the security of this implementation as the latest changes were done very fast with little to no refines of the code.

Removed WebView dependencies and moved everything to a default device browser for OAuth handling.
Updated the design.
Implemented server-side UUID v4 authentication to prevent spoofing.
Improved rate limiting and added indications for it in app as well as device recognition improvements.
Removed leftover API code related to the database and device verification.
Added auto registration and prevention of re-registration.
What's next:
- Addition of the playlist to user's Spotify account.
- Implementation of buttons that are yet to implement.
- Hosting and demo.
- Submission.

Implemented the Spotify OAuth login.
Everything works as expected, with a browser launching as soon as you click on the login button and guiding you through the login process. After logging in and returning to the app you can use all its functionality.
What's left to introduce:
- Better documentation (obviously)
- Structural changes
- Mobile app testing (since I haven't had a chance to set up mDNS on my PC)

Changed the interface and improved user experience in the EchoTuner Flutter app:
- The color scheme now features violet as the main color.
- The app has a sticky footer that's yet to fully implement.

Also added more directives to developers on setting the app up and testing it.
Further changes include Spotify logins and app funcionality improvements.

Made a very basic app, now the API can be interacted with from somewhere else, rather than making Postman requests.
Known bugs:
- [pc-name].local:[port] doesn't work on other devices.
- Setup files don't work.

I'll begin working on a redesign of the app, bugfixes and Spotify credentials' auth, as well as futher API tweaks so the integration is better with the ecosystem.
In a few days I'll try to host a web demo of this service too!

Finally implemented quite a big database of songs, artists and other preferences to pass onto the AI models to help with their tasks.
Upgraded performace MASSIVELY by running async operations instead of dealing with them one-by-one.
Next step for the API would probably be to load training data for the models directly instead of passing everything as context parsed from JSON files.
Also, an app is on its way! I can't wait to finish it!

Reworked how logs are generated, now it looks better and provides more accurate information. Tried to match the logs to how Uvicorn server is printing them out.
Still a bug when checking the Spotify search availability occurs stating it's in fallback mode (but isn't), working on a solution for it.
Improved text recognition calculation slightly, but it still needs way more patterns. They'll probably be in a database or a JSON file to avoid hardcoding data into scripts and improve mobility of the API to be available with different data sheets.

Just implemented the first version of the API!
Right now it has:
- Playlist generation (and refinement):
- Integrates with local Ollama models
- Verifies if the request is valid (still clunky, needs more context)
- Searches songs on Spotify and returns a list in JSON format
- API health checkups
- Rate limiting (needs more work and testing)

Next steps:
- Implement an app (that will handle addition of the songs to user's Spotify account and interaction with the API)
- Update the context for the songs looked up and the prompts validated to be more accurate to what the user wants

Implemented a new way to add a player to the scene! (Or any other entity, really)
Instead of having to manually set the position of an entity, now everything's possible through the same level editor used to edit levels!
Crimson's going to shift towards adding sounds, collisions and UI systems for better developer experience. After that, Crimson's game building itself awaits!