Reported from the Skeleton community:

just got a very weird interaction where I mistyped my credentials and still got into the locked area of the app but couldn't interact with anything except the logout button

Steps to reproduce:

• start writing a post and don't save it
• let the computer screen go to sleep
• open the computer again

Result:

• the post is cleared (probably the state is refreshed)

Desired outcome:

• The post should stay in the text area

One potential way to achieve this would be to save the content as it's typed in the browser local storage (or the svelte store)

Describe the bug
I wrote a journal on Sunday, but I check it today (Tuesday) found it to be Saturday.
I started the journal today morning (around 10:45 AM, EST time) Tuesday. The date initially was correct, but it turned to be Monday when I am keeping editing.

To Reproduce
Steps to reproduce the behavior:

1. Go to '...'
2. Click on '....'
3. Scroll down to '....'
4. See error

Expected behavior
I expected correct date and time if it is possible.

Screenshots
If applicable, add screenshots to help explain your problem.

Desktop (please complete the following information):

• OS: [e.g. iOS] window 10
• Browser [e.g. chrome, safari] chrome
• Version [e.g. 22] 115.0.5790.171

Smartphone (please complete the following information):

• Device: [e.g. iPhone6]
• OS: [e.g. iOS8.1]
• Browser [e.g. stock browser, safari]
• Version [e.g. 22]

Additional context
Add any other context about the problem here.

Currently we only have 4 agents. It would be good to add more agents (prompts) maybe with the ability to search/group by category/favorite.
We could fetch these ones (also add a reference): https://github.com/f/awesome-chatgpt-prompts/blob/main/prompts.csv

As a user I would like to see my OpenAI tokens usage and an estimate of the costs so I am informed about my future expense.

Implementation suggestions:

OpenAI returns the total tokens (prompt + response). We need to save these on the user private profile and potentially display it in the app in their profile popup in the header. Reset the count every month (on every OpenAI billing cycle) and have an additional total lifetime estimation.

As a user I would like to be able to track my mood across time so I can see if my happiness is improving.

Proposed implementation:

Use ChatGPT to generate the metadata for each post and return it as JSON. The metadata could contain the sentiment (negative, neutral, positive), the topics extracted from the entry.
Show a graph of the mood across time and a list of topics (like a tag cloud) than when clicked displays all entries with that topic.

As a user I would like to get suggestions for what to write every day based on my past journal entries.

The way I would approach it as a first version would be to add a new edge function for generating journal suggestions. First it would try to find last 3 journal entries no longer than 1 month, then send the following prompt to ChatGPT:

PREVIOUS JOURNAL ENTRIES:

{{ENTRIES}}

Based on the previous journal entries the User has written this month (listed above), please help the user write a new journal entry by generating 10 follow-up questions and ideas for what to write or think about.

Currently the conversations are stored in a writable localstorage store on the user's browser. They can also have only 1 conversation and if a new one is started, the old one is lost forever.
We want to save the conversations to the database and allow the users to view/resume previous conversations. Similar to how ChatGPT is doing but with a better ux (allow the users to search them, maybe categorize them using NLP)

As a user I would like to be able to lock my journal entries so that they cannot be read by someone with access to the database or someone with access to my device.

There are 2 parts to this:

1. Lock the frontend somehow with a PIN. Automatically lock after some time (let's say 5 minutes of inactivity).

2. Encrypt the journal entries and decrypt them on the frontend client. There are a few potential issues here:

• the user would be responsible for remembering/storing their private key (which they could lose and lose access to the data)
• the backend might not be able to analyze the entries properly

It would be good to initiate a discussion on this topic and brainstorm some clever ways of achieving privacy while not burdening the user too much or risking losing their precious data.

(there are some potential tools like oasislabs.com where the user could store/own their data although that's also on someone else's computer)

As a user I would like to interact with my journal just by using my voice so I can have extended conversations easier.

Is your feature request related to a problem? Please describe.
Right now, when a user signs up, they get an email from Supabase that only says "Confirm your signup \n Follow this link to confirm your user:" and gives a link to verify account. This should have more details. Specifically, it should mention Chat Journal.

Describe the solution you'd like
A longer email that says something like "Welcome to Chat Journal! This begins your journey into self-discovery using ChatGPT as a journal help [...]. Please click the following link to confirm your account before logging in the first time:"

Describe alternatives you've considered
A full-blown marketing style email with responsive design.

Additional context
This is not necessarily a very high priority for now, because Chat Journal seems to be in soft-launch. Once you're ready to hard-launch, this should become important, because people like seeing a nice, clean, professional looking email.

At the moment there is no warning that the OpenAI API key is not set. We want to show the user as soon as they sign in a persistent warning message that the analysis of their posts and the chat will not be functional until they add it with a link to the profile page where it can be set.

As a user I would like to use a trader to chat with my trading journal. Someone like George Soros maybe

As a user I would like to view similar entries (by meaning) when I go on a journal entry page.

Implementation suggestion:

• since all posts have embeddings, it's very easy to search and return a list of similar posts

Docker compose support

Docker Compose is a tool that is useful for managing and orchestrating multi-container Docker applications. It allows you to define your application’s services, networks, and volumes in a YAML file and then run and scale the entire application with a single command.

As a user I want to be able to chat using a single journal entry as context.

Implementation suggestions:

We could either show a dropdown or button on the chat screen to specify a single entry as context (maybe show a modal with a search). And on the journal entry add a button Chat about it or something like that.
Or we could include the chat on the journal entry screen and pass the entry as context.

As a user I would like to see which posts have been used as context for my conversation and be able to quickly preview them. Similar to how Bing chat is doing.

Currently if the user doesn't have an avatar set, in the header there's a broken image being displayed. We should display a generic image instead.

Currently there is no way to reset your password. We need to add a screen and a link to the login screen to that page.

Reference: https://supabase.com/docs/reference/javascript/auth-resetpasswordforemail

As a user I would like to import my existing journal entries so that I can use them as context with ChatGPT.

Currently in order to create entries you need to create each one by one. It would be good if users could drop their pdf or txt file and the platform would create the entries.

Proposed implementation:

• (drag and drop text/pdf file, then show preview with all the extracted date+content) and allow the user to remove/edit the entries then save all at once. Choose merge resolution (keel existing entries, overwrite existing with new, combine entries)
  • wizard
    • 1: drag and drop file + instructions (file size, format)
    • 2: identify dates and allow the user to de-select the ones that he doesn't want as separators
    • 3: show the list of conflicts at the top with a merge resolution and the list of entries below
    • 4: save the entries and show a success message

As a user I would like to find a previous entry not by keywords but by meaning so I can revisit my memories later.

Implementation suggestion:

• UI: Add a search in the header, that's visible on all pages
• Functionality: embed the search query and do a similarity search (all entries have embeddings already, see the chat stream as example for fetching similar entries)

As a user I want to be able to use infinite scroll in my journal entries archive so I can quickly view older posts instead of having to jump through pages.

Currently users can add an avatar by adding the URL of the image to their profile. We should allow them to upload (we already have a bucket in supabase).

Some implementation details can be found here (we need to adapt it to work on the server and with our app): https://supabase.com/docs/guides/getting-started/tutorials/with-sveltekit#bonus-profile-photos

As a user I want to be able to add pictures to my entries so I can create better memories.

Implementation details:

• it would be cool if the pictures would be included in the embeddings of the entry

Allow users to login with google (implementation was started, see the commented out sections on the Sign in and Sign up pages). There is one issue that after a successful login, you are redirected to the homepage but it still doesn't look like you're logged in until you refresh the page. This needs to be fixed and then the feature can be launched.

Describe the bug
There are accessibility warnings in the @skeletonlabs/skeleton components indicating that non-interactive elements (such as ) should not have interactive roles (option, radio, tab). These warnings appear when using Vite with Svelte in a GitHub Codespace.

To Reproduce
Steps to reproduce the behavior:

Open the project in a GitHub Codespace.
Run the development server with Vite (npm run dev).
Observe the console output for accessibility warnings related to the @skeletonlabs/skeleton components.
Specifically, look for warnings about non-interactive elements with interactive roles.
Expected behavior
The components should not have accessibility warnings. Non-interactive elements like should not have interactive roles. The components should use appropriate interactive elements (e.g.,

As a user I would like to be able to delete/export my journal entries so I can use them in another application.

The export could be a .csv file with one entry per row. Or a JSON file.