You are working on a project and your job is to implement new code changes based on given instructions.
Now you have to implement ALL changes that are related to `/path/to/save/build/output` described in development instructions listed below.
Make sure you don't make any mistakes, especially ones that could affect rest of project. Your changes will be reviewed by very detailed reviewer. Because of that, it is extremely important that you are STRICTLY following ALL the following rules while implementing changes:

# RULES FOR IMPLEMENTING CODE CHANGES
---start_of_coding_rules---

## Rule 1: Scope of your coding task
You must implement everything mentioned in the instructions that is related to this file. It can happen that instruction mention code changes needed in this file on multiple places and all of them have to be implemented now. We will not make any other changes to this file before the review and finishing this task.

## Rule 2: Output format
You must output the COMPLETE NEW VERSION of this file in following format:
---start_of_format---
```
the full contents of the updated file, without skipping over any content
```
---end_of_format---

## Rule 3: Comprehensive Codebase Insight
It's crucial to grasp the full scope of the codebase related to your tasks to avert mistakes. Check the initial conversation message for a list of files. Pay a lot of attention to files that are directly included in the file you are currently modifying or that are importing your file.
Consider these examples to guide your approach and thought process:
---start_of_examples---
- UI components or templates: Instead of placing scripts directly on specific pages, integrating them in the <head> section or as reusable partials enhances application-wide consistency and reusability.
- Database operations: Be careful not to execute an action, like password hashing, both in a routing function and a model's pre('save') hook, which could lead to redundancy and errors.
- Adding backend logic: Prior to creating new functions, verify if an equivalent function exists in the codebase that you could import and use, preventing unnecessary code duplication and keeping the project efficient.
---end_of_examples---

## Rule 4: Coding principles
Write high-quality code, first organize it logically with clear, meaningful names for variables, functions, and classes. Aim for simplicity and adhere to the DRY (Don't Repeat Yourself) principle to avoid code duplication. Pay attention not to duplicate the code that's present in other files, contents of which are below. Ensure your codebase is structured and modular for easy navigation and updates.

If the instructions have comments like `// ..add code here...` or `# placeholder for code`, instead of copying the comment, interpret the instructions and output the relevant code.

Your reply MUST NOT omit any code in the new implementation or substitute anything with comments like `// .. rest of the code goes here ..` or `# insert existing code here`, because I will overwrite the existing file with the content you provide. Output ONLY the content for this file, without additional explanation, suggestions or notes. Your output MUST start with ``` and MUST end with ``` and include only the complete file contents.

When working with configuration files (e.g. config.json, .env,...), for hardcoded configuration values that the user needs to change, mark the line that needs user configuration with `INPUT_REQUIRED {config_description}` comment,  where `config_description` is a description of the value that needs to be set by the user. Use appropriate syntax for comments in the file you're saving (for example `// INPUT_REQUIRED {config_description}` in JavaScript). NEVER ask the user to write code or provide implementation, even if the instructions suggest it! If the file type doesn't support comments (eg JSON), don't add any.

## Rule 5: Logging
Whenever you write code, make sure to log code execution so that when a developer looks at the CLI output, they can understand what is happening on the server. If the description above mentions the exact code that needs to be added but doesn't contain enough logs, you need to add the logs handlers inside that code yourself.

## Rule 6: Error handling
Whenever you write code, make sure to add error handling for all edge cases you can think of because this app will be used in production so there shouldn't be any crashes. Whenever you log the error, you **MUST** log the entire error message and trace and not only the error message. If the description above mentions the exact code that needs to be added but doesn't contain enough error handlers, you need to add the error handlers inside that code yourself.

---end_of_coding_rules---

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


Here are development instructions and now you have to focus only on changes in `/path/to/save/build/output`:
---start_of_development_instructions---


{"code":200,"status":true,"model":"gpt-4o","message":"Task #1 involves conducting a comprehensive requirements gathering session with stakeholders to understand the project's needs and objectives. This is primarily a non-coding task aimed at understanding the business needs and translating them into technical specifications. Typically, it involves meetings, interviews, and workshops with stakeholders to gather both functional and non-functional requirements. \n\nFor this task, there are no code changes or technical implementations needed in the current codebase as the focus is on gathering information and understanding objectives rather than technical development. However, I can provide a general outline of how this task would typically be approached:\n\n### Steps for Task #1: Requirements Gathering\n\n1. **Plan the Session:**\n   - Identify the key stakeholders involved in the project. This usually includes project sponsors, end-users, and sometimes technical leads.\n   - Determine the format of the sessions (e.g., one-on-one interviews, group workshops, questionnaires).\n   - Schedule the meetings ensuring maximum participation from all relevant stakeholders.\n\n2. **Conduct the Meeting:**\n   - Start with an introduction to the project's objectives as understood so far.\n   - Discuss the high-level goals and purpose of the application.\n   - Ask open-ended questions to encourage stakeholders to share their vision, needs, and expectations.\n   - Identify any constraints, priorities, and potential challenges.\n\n3. **Gather Detailed Requirements:**\n   - Functional Requirements: Features that the system must include, such as user interactions and system processes.\n   - Non-Functional Requirements: Performance, usability, security, and compliance needs.\n   - Record all information accurately using tools like requirement documentation templates, mind maps, or flowcharts.\n\n4. **Analyze and Document:**\n   - Synthesize the findings into a comprehensive requirements document or user story map.\n   - Use diagrams and charts for clarity when necessary.\n   - Ensure documentation is clear, concise, and accessible to all participants.\n\n5. **Validate and Review:**\n   - Share the documented requirements with stakeholders for feedback.\n   - Make adjustments and clarifications as necessary to ensure all needs and expectations are accurately captured.\n   - Obtain formal sign-off from stakeholders.\n\n### No Code or Technical Instructions for This Task\n\nSince task #1 consists of gathering and documenting requirements, there are no specific code changes, configuration modifications, or commands to execute for this task. The information gathered will be used to inform future development tasks, such as those involving system design or coding efforts, which will take place in subsequent tasks.\n\nIn summary, this task is about information gathering, understanding, and documenting rather than implementing code. Its results will inform and guide the technical development in later stages.","original":null}

---end_of_development_instructions---

You need to create a new file `/path/to/save/build/output`.

These files are currently implemented in the project:
---START_OF_FILES---
**`.eslintrc.cjs`** (21 lines of code):
```
module.exports = {
  root: true,
  env: { browser: true, es2020: true },
  extends: [
    'eslint:recommended',
    'plugin:react/recommended',
    'plugin:react/jsx-runtime',
    'plugin:react-hooks/recommended',
  ],
  ignorePatterns: ['dist', '.eslintrc.cjs'],
  parserOptions: { ecmaVersion: 'latest', sourceType: 'module' },
  settings: { react: { version: '18.2' } },
  plugins: ['react-refresh'],
  rules: {
    'react/jsx-no-target-blank': 'off',
    'react-refresh/only-export-components': [
      'warn',
      { allowConstantExport: true },
    ],
  },
}
```

**`.gitignore`** (24 lines of code):
```
# Logs
logs
*.log
npm-debug.log*
yarn-debug.log*
yarn-error.log*
pnpm-debug.log*
lerna-debug.log*

node_modules
dist
dist-ssr
*.local

# Editor directories and files
.vscode/*
!.vscode/extensions.json
.idea
.DS_Store
*.suo
*.ntvs*
*.njsproj
*.sln
*.sw?
```

**`index.html`** (12 lines of code):
```
<!doctype html>
<html lang="en">
  <head>
    <meta charset="UTF-8" />
    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
    <title>thisisatest</title>
  </head>
  <body>
    <div id="root"></div>
    <script type="module" src="/src/main.jsx"></script>
  </body>
</html>
```

**`package.json`** (26 lines of code):
```
{
  "name": "thisisatest",
  "private": true,
  "version": "0.0.0",
  "type": "module",
  "scripts": {
    "dev": "vite",
    "build": "vite build",
    "lint": "eslint . --ext js,jsx --report-unused-disable-directives --max-warnings 0",
    "preview": "vite preview"
  },
  "dependencies": {
    "react": "^18.2.0",
    "react-dom": "^18.2.0"
  },
  "devDependencies": {
    "@types/react": "^18.2.64",
    "@types/react-dom": "^18.2.21",
    "@vitejs/plugin-react": "^4.2.1",
    "eslint": "^8.57.0",
    "eslint-plugin-react": "^7.34.0",
    "eslint-plugin-react-hooks": "^4.6.0",
    "eslint-plugin-react-refresh": "^0.4.5",
    "vite": "^5.1.6"
  }
}
```

**`vite.config.js`** (7 lines of code):
```
import { defineConfig } from 'vite'
import react from '@vitejs/plugin-react'

// https://vitejs.dev/config/
export default defineConfig({
  plugins: [react()],
})
```

**`public/.gitkeep`** (0 lines of code):
```
```

**`src/App.css`** (7 lines of code):
```
#root {
  max-width: 1280px;
  margin: 0 auto;
  padding: 2rem;
  text-align: center;
}

```

**`src/App.jsx`** (11 lines of code):
```
import './App.css'

function App() {
  return (
    <>
      <h1>thisisatest</h1>
    </>
  )
}

export default App
```

**`src/index.css`** (20 lines of code):
```
:root {
  font-synthesis: none;
  text-rendering: optimizeLegibility;
  -webkit-font-smoothing: antialiased;
  -moz-osx-font-smoothing: grayscale;
}

body {
  margin: 0;
  display: flex;
  place-items: center;
  min-width: 320px;
  min-height: 100vh;
}

h1 {
  font-size: 3.2em;
  line-height: 1.1;
}

```

**`src/main.jsx`** (10 lines of code):
```
import React from 'react'
import ReactDOM from 'react-dom/client'
import App from './App.jsx'
import './index.css'

ReactDOM.createRoot(document.getElementById('root')).render(
  <React.StrictMode>
    <App />
  </React.StrictMode>,
)
```

**`src/assets/.gitkeep`** (0 lines of code):
```
```

**`README.md`** (1 lines of code):
```
markdown\n# thisisatest\n\nThis project is a simple ToDo application built using React. Its main purpose is to allow users to efficiently manage a list of tasks (todos). Each task has a description and a state (open or completed, with open being the default). The app provides a clean and user-friendly interface for handling daily tasks.\n\n## Overview\n\nThe application is a frontend-focused web app developed using React, featuring a simple and intuitive interface for task management. It uses Vite as the development server and bundler, which provides fast development and hot reloading capabilities. Styling is handled through Bootstrap 5, which is loaded via CDN for a responsive design.\n\nThe project files are structured as follows:\n- JavaScript and React components are located in the `src` directory.\n- Static assets reside in the `public` directory.\n- Configuration files for ESLint and Vite are present in the root directory to ensure code quality and optimal setup.\n\nCurrently, the project is set up as a frontend-only application but is designed to be compatible with any backend technology.\n\n## Features\n\n- **Display of Todos**: Users can see a list of all todo items, each displaying a description and a checkbox to indicate its state (open or completed).\n- **Add New Todo**: Users can add a new todo by clicking a button, which prompts for a task description.\n- **Toggle State**: Users can toggle a task's state between open and completed by checking or unchecking the associated checkbox.\n- **Local Storage**: The application uses the browser's local storage to persist todos, ensuring data remains available even after a page refresh.\n\n## Getting started\n\n### Requirements\n\nTo run the project, make sure your computer has the following:\n- Node.js: Required for running React development tools and building the project.\n\n### Quickstart\n\n1. Clone the repository to your local machine.\n2. Navigate to the project directory.\n3. Install dependencies using `npm install`.\n4. Start the development server with `npm run dev`.\n5. Open a browser and navigate to `http://localhost:3000` to see the application in action.\n\n### License\n\nThe project is proprietary. Copyright (c) 2024.\n```","original":null}```

---END_OF_FILES---