You are working on a App called "thisisatest" and your job is to review changes made.

Here is a high level description of "thisisatest":
```
{"code":200,"status":true,"model":"gpt-4o","message":"The application is a simple ToDo app built using React. Its primary function is to allow users to manage a list of tasks (todos). Each task has a description and a state (open or completed, with the default state being open). The application is frontend-only, with no user sign-up or authentication process. The goal is to provide a straightforward and user-friendly interface for task management.\n\nFeatures:\n1. Display of Todos: A list that displays all todo items. Each item shows its description and a checkbox to indicate its state (open or completed).\n2. Add New Todo: A button to add a new todo item. Clicking this button will prompt the user to enter a description for the new todo.\n3. Toggle State: Each todo item includes a checkbox. Checking/unchecking this box toggles the todo's state between open and completed.\n4. Local Storage: The application will use the browser's local storage to persist todos between sessions, ensuring that users do not lose their data upon reloading the application.\n5. Data Persistence: The application will also use an SQL backend to store todos persistently.\n\nFunctional Specification:\n- Upon loading the application, it fetches existing todos from the local storage and displays them in a list, and syncs with the SQL database.\n- Each todo item in the list displays a checkbox and a description. The checkbox reflects the todo's current state (checked for completed, unchecked for open).\n- When the user checks or unchecks a checkbox, the application updates the state of the corresponding todo item and saves the updated list to local storage and SQL database.\n- Clicking the \"Add New Todo\" button prompts the user to enter a description for the new todo. Upon confirmation, the application adds the new todo (with the default state of open) to the list and updates local storage and SQL database.\n- The application does not support deleting or editing todo items to keep the interface and interactions simple.\n- Todos persist between sessions using the browser's local storage and SQL backend. The application saves any changes to the todo list (additions or state changes) in local storage and SQL database and retrieves this data when the application is reloaded.\n\nTechnical Specification:\n- Platform/Technologies: The application is a web application developed using React on frontend and Express on the backend, using SQLite as the database.\n- Styling: Use Bootstrap 5 for a simple and functional interface. Load Boostrap from the CDN (don't install it locally):\n    - https://cdn.jsdelivr.net/npm/bootstrap@5.0.2/dist/css/bootstrap.min.css\n    - https://cdn.jsdelivr.net/npm/bootstrap@5.0.2/dist/js/bootstrap.bundle.min.js\n- State Management: Directly in the React component\n    - make sure to initialize the state from the local storage as default (... = useState(JSON.parse(localStorage.getItem('todos')) || []) to avoid race conditions\n- Data Persistence: Using the SQLite database on the backend via a REST API.","original":null}
```


Here are the technologies that should be used for this project:
* Node.js - JavaScript runtime needed to run the React development tools and build the project.

* react - A JavaScript library for building user interfaces.
* react-dom - Serves as the entry point to the DOM and server renderers for React.
* bootstrap - Frontend framework for developing responsive and mobile-first websites.

Here's what's already been implemented:

* React web app using Vite devserver/bundler
* Initial setup with Vite for fast development
* Basic project structure for React development
* Development server setup for hot reloading
* Minimal configuration to get started with React
* Frontend-only, compatible with any backend stack



Here is the feature that you are implementing right now:
```
half of the features are missing or incomplete
```

Development process of this app was split into smaller tasks. Here is the list of all tasks:
```
1. Conduct a comprehensive requirements gathering session with stakeholders to understand the project's needs and objectives.
2. Design the system architecture, including database schema, API endpoints, and overall software stack.
3. Develop the user interface, ensuring responsiveness and accessibility across different devices.
4. Implement backend services and business logic, integrating with necessary third-party APIs and services.
5. Perform extensive testing, including unit, integration, and user acceptance testing, to ensure system reliability and performance.
6. Prepare deployment strategy and continuous integration and delivery pipelines for smooth rollout and updates.
7. Develop comprehensive documentation and conduct training sessions for users and stakeholders.
8. Set up monitoring and analytics tools to track system performance and user engagement post-launch.
```

You are currently working on, and have to focus only on, this task:
```
Conduct a comprehensive requirements gathering session with stakeholders to understand the project's needs and objectives.
```

A part of the app is already finished.
These files are currently implemented in the project:
* `.eslintrc.cjs: Configuration file for ESLint, a static code analysis tool for identifying problematic patterns found in JavaScript code. It defines rules for linting JavaScript code with a focus on React applications.`
* `.gitignore: Specifies patterns to exclude files and directories from being tracked by Git version control system. It is used to prevent certain files from being committed to the repository.`
* `index.html: Main entry point for the project. It includes a basic HTML structure with a root div element and a script tag importing a JavaScript file named main.jsx using the module type. References: src/main.jsx`
* `package.json: Standard Nodejs package metadata file, specifies dependencies and start scripts. It also specifies that the project is a module.`
* `vite.config.js: Configuration file for Vite, a fast developer-friendly Javascript bundler/devserver.`
* `public/.gitkeep: Empty file`
* `src/App.css: Contains styling rules for the root element of the application, setting a maximum width, centering it on the page, adding padding, and aligning text to the center.`
* `src/App.jsx: Defines a functional component that serves as the root component in the project. The component is exported as the default export. References: src/App.css`
* `src/index.css: Defines styling rules for the root element, body, and h1 elements of a web page.`
* `src/main.jsx: Main entry point for a React application. It imports necessary modules, renders the main component 'App' inside a 'React.StrictMode' component, and mounts it to the root element in the HTML document. References: App.jsx, index.css`
* `src/assets/.gitkeep: Empty file`
* `README.md: This file is responsible for handling user authentication in the application. It includes classes and functions for login, logout, and registration processes. Major functionalities include validating user credentials, hashing passwords, and managing user sessions. The file also defines decorators for access control and manages user authentication state throughout the application.`

Here are the complete contents of files relevant to this task:
---START_OF_FILES---
---END_OF_FILES---

Files that were modified during implementation of the task are:

Now I will show you how those files looked before this task implementation started. If a file is listed as the file that changed but is not in this list that means it was created during this task. Here are files before implementation of this task:

---start_of_files_at_start_of_task---
---end_of_files_at_start_of_task---

**IMPORTANT**
You have to review this task implementation. You are known to be very strict with your reviews and very good at noticing bugs but you don't mind minor changes like refactoring, adding or removing logs and so on. You think twice through all information given before giving any conclusions.

Each task goes through multiple reviews and you have to focus only on your part of review.
In this review, your goal is to check:
1. If there are some functionalities that were removed but are still needed.
2. If new files or functions are created but never called or used.
3. If there is some "dead code" that should be removed.
4. If there is some duplicate code resulting from refactoring or moving code into separate classes or files.

If everything is ok respond only with "DONE" and nothing else. Do NOT respond with thoughts, reasoning, explanations or anything similar if everything is ok, respond just with "DONE".

If you find any of these 4 mistakes, describe in detail what has to be changed.

**IMPORTANT**: Pay attention to file paths: if the command or argument is a file or folder from the project, use paths relative to the project root.
 For example:
 - use `dirname/filename.py` instead of `/path/to/project/dirname/filename.py`
 - use `filename.js` instead of `./filename.js`
All the steps will be executed in order in which you give them, so it is very important that you think about all steps before you start listing them. For example, you should never code something before you install dependencies or you should never try access a file before it exists in project.