$ gptsh list all the files in the current directory
 

Generated Command:
```bash
ls
```

Do you want to execute this command? (Y/n) Y
CoolTerm  Documents  Music     Public		  snap	     Videos
Desktop   Downloads  Pictures  RustroverProjects  Templates

$ gptsh generate a python script to find all my python files
 

Generated Command:
```bash
echo -e "import os\n\nfor root, dirs, files in os.walk('.'): \n\tfor file in files:\n\t\tif file.endswith('.py'):\n\t\t\tprint(os.path.join(root, file))" > find_python_files.py
```

Do you want to execute this command? (Y/n) Y
$ ls
CoolTerm   Downloads             Pictures           snap      
Desktop    find_python_files.py  Public             Templates
Documents  Music                 RustroverProjects  Videos

$ gptsh create the automation to compression and back up my pictures weekly 

Generated Command:
```bash
echo "0 0 * * 0 tar -czf \$HOME/backup/pictures_backup_\$(date +\%Y\%m\%d).tar.gz -C \$HOME/Pictures ." | crontab -
```

Do you want to execute this command? (Y/n) y
$ gptsh show me my cron jobs
 

Generated Command:
```bash
crontab -l
```

Do you want to execute this command? (Y/n) 
0 0 * * 0 tar -czf $HOME/backup/pictures_backup_$(date +\%Y\%m\%d).tar.gz -C $HOME/Pictures .

$ gptsh create a single bash script to solve world hunger and bring world peace
 

Generated Command:
```bash
#!/bin/bash
echo "Solving world hunger and bringing world peace cannot be achieved by a script. It requires global cooperation, sustainable development, and compassionate leadership."
```

Do you want to execute this command? (Y/n) Y           
Solving world hunger and bringing world peace cannot be achieved by a script. It requires global cooperation, sustainable development, and compassionate leadership.

$ gptsh creat a new directory and add a couple of sample files to it
 

Generated Command:
```bash
mkdir new_directory && touch new_directory/sample_file1.txt new_directory/sample_file2.txt
```

Do you want to execute this command? (Y/n) 

gptsh --help
Usage: gptsh [OPTIONS] [PROMPT]
Options:
--help, -h        Show this help message
--shell           Run in continuous shell mode
--chat            Run in chat mode with GPT-4
--no-execute      Output the generated command without executing it

$ gptsh --shell
Entering continuous shell mode. Type 'exit' to quit.
[gptsh]:user:~/RustroverProjects/gptsh$ clear out my chron jobs
 

Generated Command:
```bash
crontab -r
```

Do you want to execute this command? (Y/n) 
[gptsh]:user:~/RustroverProjects/gptsh$ 

$ gptsh --chat
Entering chat mode. Type 'exit' or 'quit' to end the session.
You: What's up frendo?
 

gptsh: Hello, pal! I'm here to assist you. How may I aid you today?

You: tell me about how write good software
 

gptsh: Absolutely, buddy! Writing good software revolves around several principles:

**1. Understand the Problem:** Before writing a single line of code, it's essential to have a clear understanding of the problem you aim to solve through software.

**2. Plan:**
Layout a blueprint of your software architecture. Sketch workflows and identify components and their interactions.

**3. Write Clean and Readable Code:**
Your code should be easy to understand and maintain. Consistently follow naming conventions, use accurate comments, and avoid coding practices that make your code complex.

**4. Maintainability:**
The codebase should be organised to make updates and modifications easy. High cohesion (grouping related functionalities) and low coupling (minimise interdependence between components) are key principles here.

**5. Test Thoroughly:**
Robust software is tested well before deployment. Automated tests, manual testing, and even user acceptance testing help identify bugs and issues before they become problems.

**6. Refine and Refactor:**
Good software is continuously improved. Regularly check for areas of improvement and refactor code to make it more efficient, readable or maintainable.

**7. Documentation:**
A well-documented codebase is a dream to work with, often easier to understand and debug. Usage, configuration, installation, and any other essential information should be clearly documented.

These are the fundamental principles of writing good software. However, the list doesn't end here. There are many more practices that depend on context, personal experience, team guidelines, etc.

You: Awesome! save that for me to read later
 

gptsh: Sure thing, pal!

 
About to execute command: 'echo '1. Understand the Problem: Before writing a single line of code, it\'s essential to have a clear understanding of the problem you aim to solve through software.

...

7. Documentation: A well-documented codebase is a dream to work with, often easier to understand and debug. Usage, configuration, installation, and any other essential information should be clearly documented.
' > good_software_guidelines.md'
Do you want to proceed? [Y/n] Y

 

gptsh: Done, pal! I have written the information about good software practices to a file named `good_software_guidelines.md`. You can access it anytime for your reference!

Anything else I can assist you with today?

You: nope, let's call it a day
 
See you later pal.
$

$ gptsh --no-execute remove all these dang files!
 
```bash
rm -rf *
```