notee 0.1.0__tar.gz

notee-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 lusparkl
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

notee-0.1.0/PKG-INFO

@@ -0,0 +1,67 @@
+Metadata-Version: 2.4
+Name: notee
+Version: 0.1.0
+Summary: Python CLI to create md files with terminal in seconds
+Requires-Python: >=3.12, <3.14.2
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: mdutils>=1.8.1
+Requires-Dist: typer>=0.24.1
+Requires-Dist: chromadb>=1.5.2
+Requires-Dist: InquirerPy>=0.3.4
+Requires-Dist: openai>=2.26.0
+Requires-Dist: google-genai>=1.66.0
+Requires-Dist: openrouter>=0.7.11
+
+# Notee
+
+## Notee is python CLI that is able to fully replace your note making app or just be your fast way to create notes in terminal with additional functionality.
+
+Sometimes I have an idea that comes from nowhere and to note it I have to open my obsidian app, create file and only then write my note, it's too slow. I created python CLI that will allow you to start writing your notes just after one command of 9 characters. Also there is functionality like ai module or search with vector database included.
+
+## Technologies
+
+* [Typer](https://typer.tiangolo.com/) - to realize CLI functionality.
+* [Chroma DB](https://www.trychroma.com/) - vector db for AI context and extendet search through your notes.
+* [MdUtils](https://pypi.org/project/mdutils/) - for the md files creation.
+* [Rich](https://rich.readthedocs.io/en/stable/index.html) - to make prints prettier.
+
+---
+
+## How to use
+
+1. Install package by running `pipx install notee`.
+2. Run `notee setup` and go throught instuctions in the console.
+
+**Done!** Now you can use it freely🎉
+
+---
+
+## Commands
+
+- `setup` - setup notee before using it. 
+- `idea` - create idea note.
+- `movie` - create movie review note.
+- `book` - create book review note.
+- `source` - create note about source to something.
+- `todo` - create todo note.
+- `search QUERY` - search notes related to your query.
+- `open` - open your note in the terminal.
+- `scan` - scan your vault and add new notes to the database.
+- `obsidian_mode --on/--off` - use to manage obsidian mode(only affects how tags are created).
+- `different_folders --on/--off` - toggle between creating folder for each tipe of template or store all notes in core folder.
+- `ai_module --on/-off` - toggle between using ai module or not.
+- `setup_ai` - change Ai provider/api key.
+- `ask QUERY` - ask AI question and it'll answer it based on your notes.
+- `change_ai_model AI_MODEL_NAME` - change default ai model. Please be careful and make sure that you're passing correct model name.
+
+| AI provider | Default model |
+|----------|----------|
+| Open AI | `gpt-4.1-mini-2025-04-14` |
+| Google Gemini | `gemini-2.5-flash` |
+| Hack Club AI API | `google/gemini-2.5-flash` |
+
+## Found error?
+
+Please let me know about it by submitting issue on the github repository. I'll try to fix it as fast as possible!
+

notee-0.1.0/README.md

@@ -0,0 +1,51 @@
+# Notee
+
+## Notee is python CLI that is able to fully replace your note making app or just be your fast way to create notes in terminal with additional functionality.
+
+Sometimes I have an idea that comes from nowhere and to note it I have to open my obsidian app, create file and only then write my note, it's too slow. I created python CLI that will allow you to start writing your notes just after one command of 9 characters. Also there is functionality like ai module or search with vector database included.
+
+## Technologies
+
+* [Typer](https://typer.tiangolo.com/) - to realize CLI functionality.
+* [Chroma DB](https://www.trychroma.com/) - vector db for AI context and extendet search through your notes.
+* [MdUtils](https://pypi.org/project/mdutils/) - for the md files creation.
+* [Rich](https://rich.readthedocs.io/en/stable/index.html) - to make prints prettier.
+
+---
+
+## How to use
+
+1. Install package by running `pipx install notee`.
+2. Run `notee setup` and go throught instuctions in the console.
+
+**Done!** Now you can use it freely🎉
+
+---
+
+## Commands
+
+- `setup` - setup notee before using it. 
+- `idea` - create idea note.
+- `movie` - create movie review note.
+- `book` - create book review note.
+- `source` - create note about source to something.
+- `todo` - create todo note.
+- `search QUERY` - search notes related to your query.
+- `open` - open your note in the terminal.
+- `scan` - scan your vault and add new notes to the database.
+- `obsidian_mode --on/--off` - use to manage obsidian mode(only affects how tags are created).
+- `different_folders --on/--off` - toggle between creating folder for each tipe of template or store all notes in core folder.
+- `ai_module --on/-off` - toggle between using ai module or not.
+- `setup_ai` - change Ai provider/api key.
+- `ask QUERY` - ask AI question and it'll answer it based on your notes.
+- `change_ai_model AI_MODEL_NAME` - change default ai model. Please be careful and make sure that you're passing correct model name.
+
+| AI provider | Default model |
+|----------|----------|
+| Open AI | `gpt-4.1-mini-2025-04-14` |
+| Google Gemini | `gemini-2.5-flash` |
+| Hack Club AI API | `google/gemini-2.5-flash` |
+
+## Found error?
+
+Please let me know about it by submitting issue on the github repository. I'll try to fix it as fast as possible!

notee-0.1.0/notee/ai/api_key_alive.py

@@ -0,0 +1,40 @@
+from google import genai
+import openrouter
+import requests
+import google
+import openai
+
+def openai_apikey_check(api_key: str) -> bool:
+    client = openai.Client(api_key=api_key)
+    try:
+        client.models.list()
+        return True
+    except openai.AuthenticationError:
+        return False
+
+def gemini_apikey_check(api_key: str) -> bool:
+    client = genai.Client(api_key=api_key)
+    try:
+        client.models.list()
+        return True
+    except google.genai.errors.ClientError:
+        return False
+
+def hackclub_apikey_check(api_key: str) -> bool:
+    client = openrouter.OpenRouter(
+        api_key=api_key,
+        server_url="https://ai.hackclub.com/proxy/v1",
+    )
+
+    try:
+        client.chat.send(model="google/gemini-2.5-flash",
+            messages=[{"role": "user", "content": "Tell me a joke."}],
+            max_tokens=5
+        )
+        return True
+    except openrouter.errors.openrouterdefaulterror.OpenRouterDefaultError:
+        return False
+
+    
+
+

notee-0.1.0/notee/ai/gemini.py

@@ -0,0 +1,21 @@
+from notee.cli.utils.logs import send_error
+from notee.db.query import get_context_for_ai
+from notee.ai.api_key_alive import gemini_apikey_check
+from notee.cli.utils.config import get_config
+from google import genai
+
+def gemini_request(query):
+    config = get_config()
+    api_key = config["settings"]["AI_api_key"]
+    model = config["settings"]["AI_model"]
+    client = genai.Client(api_key=api_key)
+
+    if not gemini_apikey_check(api_key):
+        send_error("Your Gemini api key is not valid. Please change it with <notee change_api_key>.")
+    
+    responce = client.models.generate_content(
+        model=model,
+        contents=f"You are ai model that is connected to the CLI notes app. Your main goal is to give persise responces without water to user based on their notes related to question. This is notes: {get_context_for_ai(query)}. \n\n This is user request: {query}"
+    )
+
+    return responce.text

notee-0.1.0/notee/ai/hackclub.py

@@ -0,0 +1,34 @@
+from notee.ai.api_key_alive import hackclub_apikey_check
+from notee.db.query import get_context_for_ai
+from notee.cli.utils.config import get_config
+from notee.cli.utils.logs import send_error
+from openrouter import OpenRouter
+
+def hackclub_request(query):
+    config = get_config()
+    api_key = config["settings"]["AI_api_key"]
+    model = config["settings"]["AI_model"]
+    client = OpenRouter(
+        api_key=api_key,
+        server_url="https://ai.hackclub.com/proxy/v1",
+    )
+
+    if not hackclub_apikey_check(api_key):
+        send_error("Your HackClub api key is not valid. Please change it with <notee change_api_key>.")
+
+    response = client.chat.send(
+        model=model,
+        messages=[
+            {"role": "user", "content": query},
+            {"role": "system", "content": f"You are ai model that is connected to the CLI notes app. Your main goal is to give persise responces without water to user based on their notes related to question. This is notes: {get_context_for_ai(query)}"}
+        ],
+        stream=False,
+    )
+
+    return response.choices[0].message.content
+    
+
+
+
+
+

notee-0.1.0/notee/ai/openai.py

@@ -0,0 +1,23 @@
+from notee.cli.utils.logs import send_error
+from notee.ai.api_key_alive import openai_apikey_check
+from notee.db.query import get_context_for_ai
+from notee.cli.utils.config import get_config
+import openai
+
+def openai_request(query) -> str:
+    config = get_config()
+    api_key = config["settings"]["AI_api_key"]
+    model = config["settings"]["AI_model"]
+    client = openai.Client(api_key=api_key)
+
+    if not openai_apikey_check(api_key):
+        send_error("Your openAI api key is not valid. Please change it with <notee change_api_key>.")
+        return
+
+    responce = client.responses.create(
+        model=model,
+        input=query,
+        instructions=f"You are ai model that is connected to the CLI notes app. Your main goal is to give persise responces without water to user based on their notes related to question. This is notes: {get_context_for_ai(query)}"
+    )
+
+    return responce.output_text

notee-0.1.0/notee/ai/setup_ai.py

@@ -0,0 +1,53 @@
+from notee.ai.api_key_alive import openai_apikey_check, gemini_apikey_check, hackclub_apikey_check
+from notee.cli.utils.logs import send_process, send_error
+from prompt_toolkit.completion import WordCompleter
+from prompt_toolkit.styles import Style
+from prompt_toolkit import prompt
+import typer
+
+def setup_ai() -> list:
+    
+    custom_style = Style.from_dict({
+        "completion-menu": "bg:#1e1e1e #d4d4d4",         
+        "completion-menu.completion": "bg:#2d2d2d #bbbbbb",
+        "completion-menu.completion.current": "bg:#3a3a3a #ffffff bold underline", 
+        "scrollbar.background": "bg:#121212",            
+        "scrollbar.button": "bg:#444444",                
+    })
+
+    ai_providers = ["OpenAI", "Google Gemini", "HackClub API"]
+    providers_completer = WordCompleter(ai_providers, ignore_case=True, match_middle=True)
+    send_process("Choose your AI provider:")
+    user_choise = prompt(">", completer=providers_completer, complete_while_typing=True, style=custom_style)
+
+    if user_choise not in ai_providers:
+        send_error("Don't have this one yet. Please choose between providers that already implemented.")
+        setup_ai()
+    
+    match user_choise:
+        case "OpenAI":
+            send_process("Now enter your OpenAI api key:")
+            api_key = typer.prompt(">")
+            
+            if not openai_apikey_check(api_key):
+                setup_ai()
+
+            return ["OpenAI", "gpt-4.1-mini-2025-04-14", api_key]
+
+        case "Google Gemini":
+            send_process("Now enter your Google Gemini api key:")
+            api_key = typer.prompt(">")   
+
+            if not gemini_apikey_check(api_key):
+                setup_ai()
+
+            return ["Google Gemini", "gemini-2.5-flash", api_key]
+
+        case "HackClub API":
+            send_process("Now enter your Hack Club api key:")
+            api_key = typer.prompt(">")
+
+            if not hackclub_apikey_check(api_key):
+                setup_ai()
+
+            return ["HackClub API", "google/gemini-2.5-flash", api_key] 

notee-0.1.0/notee/cli/commands/ask.py

@@ -0,0 +1,37 @@
+from notee.ai.hackclub import hackclub_request
+from notee.cli.utils.config import get_config
+from notee.cli.utils.logs import send_error
+from notee.ai.gemini import gemini_request
+from notee.ai.openai import openai_request
+from rich.console import Console
+from typing import Annotated
+import typer
+
+app = typer.Typer()
+
+@app.command("ask")
+def ask(query: Annotated[str, typer.Argument(help="Query for your request.")]):
+    """Ask AI question and it'll answer it based on your notes."""
+    console = Console()
+
+    with console.status(" ", spinner="dots"):
+        config = get_config()
+    
+        if config["settings"]["AI_module"] == "n":
+            send_error("Your ai module isn't setup yet. Use <notee setup_ai> to use this command.")
+            return
+    
+        ai_provider = config["settings"]["AI_provider"]
+        match ai_provider:
+            case "OpenAI":
+                responce = openai_request(query)
+            case "Google Gemini":
+                responce = gemini_request(query)
+            case "HackClub API":
+                responce = hackclub_request(query)
+            case _ :
+                send_error("Something wrong happened. Try to setup your ai module again with <notee setup_ai>.")
+            
+        print(responce)
+        
+    

notee-0.1.0/notee/cli/commands/change_ai_model.py

@@ -0,0 +1,14 @@
+from notee.cli.utils.config import get_config, save_config
+from notee.cli.utils.logs import send_success
+from typing import Annotated
+import typer
+
+app = typer.Typer()
+
+@app.command("change_ai_model")
+def change_ai_model(model_name: Annotated[str, typer.Argument(help="Model name from official docs.")]):
+    """Change your ai model from the default one. Please be careful, if you pick something wrong ai module might stop working till you change model to working one."""
+    config = get_config()
+    config["settings"]["AI_model"] = model_name
+    save_config(config)
+    send_success(f"Changed your AI model to the {model_name}. Make sure that it exists!")

notee-0.1.0/notee/cli/commands/change_ai_setup.py

@@ -0,0 +1,19 @@
+from notee.cli.utils.config import get_config, save_config
+from notee.cli.utils.logs import send_success
+from notee.ai.setup_ai import setup_ai
+import typer
+
+app = typer.Typer()
+
+@app.command("setup_ai")
+def change_ai_setup():
+    """Change AI provider/api key"""
+    config = get_config()
+    provider, model, api_key = setup_ai()
+    config["settings"]["AI_module"] = "y"
+    config["settings"]["AI_provider"] = provider
+    config["settings"]["AI_model"] = model
+    config["settings"]["AI_api_key"] = api_key
+
+    send_success("AI setup finished!")
+    save_config(config)

notee-0.1.0/notee/cli/commands/create_book.py

@@ -0,0 +1,34 @@
+from notee.cli.utils.logs import send_process, send_warning, send_success
+from notee.templates.book import create_book_note
+from notee.db.add_file import add_file_to_db
+from typing import Annotated
+import typer
+
+app = typer.Typer()
+
+@app.command("book")
+def create_book(title: Annotated[str, typer.Argument(help="Title and name for your book note.")]):
+    """
+    Create book review note
+    """
+    send_process(f"Alright, creating book with title {title}.")
+    author = typer.prompt("What is the author of the book?", default="")
+    notes = typer.prompt("Write some of your notes about book", default="")
+    tags = typer.prompt("Now enter tags for this file, separate them by spaces", default="")
+    rating = None
+    while not rating:
+        resp = typer.prompt("Enter rating for this book from 0 to 10", default="")
+        try:
+            if int(resp) >=0 and int(resp) <= 10:
+                rating = int(resp)
+            elif resp == None:
+                break
+            else:
+                send_warning("Please enter number from 0 to 10 to rate your book.")
+        except:
+            send_warning("Please enter number from 0 to 10 to rate your book.")
+    
+    text, path, date = create_book_note(title, author, notes, tags, rating)
+    add_file_to_db(text, path, date)
+    send_success(f"Created note {title}")
+    

notee-0.1.0/notee/cli/commands/create_idea.py

@@ -0,0 +1,19 @@
+from notee.cli.utils.logs import send_process, send_success
+from notee.db.add_file import add_file_to_db
+from notee.templates.idea import create_idea_note
+from typing import Annotated
+import typer
+
+app = typer.Typer()
+
+@app.command("idea")
+def create_idea(title: Annotated[str, typer.Argument(help="Title and name for your idea note.")]):
+    """Create idea note"""
+    send_process(f"Alright, creating idea note '{title}'.")
+    description = typer.prompt("Describe your idea", default="")
+    tags = typer.prompt("Now enter tags for this file, separate them by spaces", default="")
+
+    text, path, date = create_idea_note(title, description, tags)
+    add_file_to_db(text, path, date)
+    send_success(f"Created note {title}")
+

notee-0.1.0/notee/cli/commands/create_movie.py

@@ -0,0 +1,30 @@
+from notee.cli.utils.logs import send_process, send_success, send_warning
+from notee.db.add_file import add_file_to_db
+from notee.templates.movie import create_movie_note
+from typing import Annotated
+import typer
+
+app = typer.Typer()
+
+@app.command("movie")
+def create_movie(title: Annotated[str, typer.Argument(help="Title and name for your movie note.")]):
+    """Create movie review note"""
+    send_process(f"Allright, creating note for {title} movie.")
+    notes = typer.prompt("Write some of your notes about this movie", default="")
+    tags = typer.prompt("Now enter tags for this file, separate them by spaces", default="")
+    rating = None
+    while not rating:
+        resp = typer.prompt("Enter rating for this movie from 0 to 10", default="")
+        try:
+            if int(resp) >=0 and int(resp) <= 10:
+                rating = int(resp)
+            elif resp == None:
+                break
+            else:
+                send_warning("Please enter number from 0 to 10 to rate your movie.")
+        except:
+            send_warning("Please enter number from 0 to 10 to rate your movie.")
+    
+    text, path, date = create_movie_note(title, notes, tags, rating)
+    add_file_to_db(text, path, date)
+    send_success(f"Created note {title}")

notee-0.1.0/notee/cli/commands/create_source.py

@@ -0,0 +1,19 @@
+from notee.cli.utils.logs import send_process, send_success
+from notee.templates.source import create_source_note
+from notee.db.add_file import add_file_to_db
+from typing import Annotated
+import typer
+
+app = typer.Typer()
+
+@app.command("source")
+def create_source(title: Annotated[str, typer.Argument(help="Title and name for your source note.")]):
+    """Create note with source for smth"""
+    send_process(f"Allright, creating note for {title} source.")
+    notes = typer.prompt("Write some of your notes about this source", default="")
+    links = typer.prompt("Write links to this source, separate them by space too", default="")
+    tags = typer.prompt("Now enter tags for this file, separate them by spaces", default="")
+    
+    text, path, date = create_source_note(title, notes, tags, links)
+    add_file_to_db(text, path, date)
+    send_success(f"Created note {title}")

notee-0.1.0/notee/cli/commands/create_todo.py

@@ -0,0 +1,18 @@
+from notee.cli.utils.logs import send_process, send_success
+from notee.templates.todo import create_todo_note
+from notee.db.add_file import add_file_to_db
+from typing import Annotated
+import typer
+
+app = typer.Typer()
+
+@app.command("todo")
+def create_idea(title: Annotated[str, typer.Argument(help="Title and name for your todo note.")]):
+    """Create todo note"""
+    send_process(f"Alright, creating todo note '{title}'.")
+    description = typer.prompt("Describe what you need to do", default="")
+    tags = typer.prompt("Now enter tags for this file, separate them by spaces", default="")
+
+    text, path, date = create_todo_note(title, description, tags)
+    add_file_to_db(text, path, date)
+    send_success(f"Created note {title}")

notee-0.1.0/notee/cli/commands/open.py

@@ -0,0 +1,33 @@
+from notee.cli.utils.logs import send_error, send_process
+from prompt_toolkit.completion import WordCompleter
+from notee.db.get_file_patches import get_file_pathes
+from notee.cli.utils.view_md import view_md_file
+from prompt_toolkit.styles import Style
+from prompt_toolkit import prompt
+import typer
+
+app = typer.Typer()
+
+@app.command("open")
+def open_note():
+    """Open some note in terminal"""
+    
+    custom_style = Style.from_dict({
+        "completion-menu": "bg:#1e1e1e #d4d4d4",         
+        "completion-menu.completion": "bg:#2d2d2d #bbbbbb",
+        "completion-menu.completion.current": "bg:#3a3a3a #ffffff bold underline", 
+        "scrollbar.background": "bg:#121212",            
+        "scrollbar.button": "bg:#444444",                
+    })
+
+    pathes = get_file_pathes()
+    pathes_completer = WordCompleter(pathes, ignore_case=True, match_middle=True)
+    send_process("Enter path for your note:")
+    user_choise = prompt(">", completer=pathes_completer, complete_while_typing=True, style=custom_style)
+    
+    if user_choise not in pathes:
+        send_error("Can't find this path in db. Please use <notee scan> and try again.")
+        return
+        
+    view_md_file(user_choise)
+

notee-0.1.0/notee/cli/commands/scan.py

@@ -0,0 +1,20 @@
+from notee.cli.utils.logs import send_success
+from notee.cli.utils.config import get_config
+from notee.cli.utils.scaner import scan
+from rich.console import Console
+import typer
+
+app = typer.Typer()
+
+@app.command("scan")
+def scan_folder():
+    """Scan folder to add notes to the db if they're not already there."""
+    console = Console()
+    with console.status(" ", spinner="dots"):
+        config = get_config()
+        notes_folder = config["patches"]["base_folder"]
+        n_new_files = scan(notes_folder)
+    if n_new_files:
+        send_success(f"Scanned your vault, added {n_new_files} new files to the db!")
+    else:
+        send_success("Scanned your vault. Nothing new appeared from last scan.")

notee-0.1.0/notee/cli/commands/search.py

@@ -0,0 +1,30 @@
+from notee.cli.utils.logs import send_success, send_warning
+from notee.cli.utils.view_md import view_md_file
+from notee.db.query import search_in_db
+from rich.console import Console
+from InquirerPy import inquirer
+from typing import Annotated
+import typer
+
+app = typer.Typer()
+
+@app.command("search")
+def search(query: Annotated[str, typer.Argument(help="Query for your search request")]):
+    """Search for your note by query"""
+    console = Console()
+
+    with console.status(" ", spinner="dots"):
+        responce = search_in_db(query)
+    if not responce:
+        send_warning("Can't find anything😢 Try another query.")
+        return
+    
+    responce.append("Exit")
+    send_success("Here is your notes:")
+    choice = inquirer.select(message="Select please", choices=responce, default="Exit").execute()
+    
+    if choice == "Exit":
+        return
+    
+    view_md_file(choice)
+

notee-0.1.0/notee/cli/commands/setup.py

@@ -0,0 +1,73 @@
+from notee.cli.utils.logs import send_success, send_process, send_error, send_warning
+from notee.cli.utils.disk_operations import create_config_file, is_folder_exists
+from notee.db.create_db import create_db
+from notee.ai.setup_ai import setup_ai
+from pathlib import Path
+from typer import Typer
+import configparser
+import typer
+ 
+app = Typer()
+ 
+@app.command("setup")
+def setup():
+    """Setup notee before using it."""
+    config_path = create_config_file()
+    config = configparser.ConfigParser()
+    config["patches"] = {}
+    config.add_section("settings")
+    TEMPLATES = ["book", "idea", "movie", "source", "todo"]
+
+    send_process("Now it's time to setup your notes folder.")
+    path = typer.prompt("Enter folder path")
+    exists = is_folder_exists(path)
+    if not exists:
+        send_error(f"Can't find folder {path}, please provide already created folder.")
+        return
+    
+    config["patches"]["base_folder"] = path
+    send_process("Create different folders for each temlate type?")
+    different_folders = typer.confirm("Create different folders?")
+    
+    if different_folders:
+        for template in TEMPLATES:
+            template_folder_path = Path(f"{path}/{template}")
+            template_folder_path.touch()
+            config["patches"][template] = f"{path}/{template}"
+    else:
+        for template in TEMPLATES:
+            config["patches"][template] = path
+    
+    send_process("Create notes with default MD or for obsidian? (You can change it later)")
+    obsidian_mode = typer.confirm("Use obsidian mode?")
+
+    if obsidian_mode:
+        config["settings"]["obsidian_mode"] = "y"
+    else:
+        config["settings"]["obsidian_mode"] = "n"
+    
+    send_process("Now enter path for the database folder (we'll need it for search feature and AI interactions)")
+    db_path = typer.prompt("Database folder")
+    exists = is_folder_exists(path)
+    if not exists:
+        send_error(f"Can't find folder {path}, please provide already created folder.")
+        return
+    config["settings"]["db_path"] = db_path
+    create_db(db_path)
+
+    send_process("Do you want to use notee AI module?(You can change it later)")
+    ai_module = typer.confirm("Use ai module?")
+
+    if ai_module:
+        provider, model, api_key = setup_ai()
+        config["settings"]["AI_module"] = "y"
+        config["settings"]["AI_provider"] = provider
+        config["settings"]["AI_model"] = model
+        config["settings"]["AI_api_key"] = api_key
+    else:
+        config["settings"]["AI_module"] = "n"    
+    
+    with open(config_path, 'w', encoding='utf-8') as configfile:
+        config.write(configfile)
+
+    send_success("Finished setup! Use <notee --help> to get all commands")

notee-0.1.0/notee/cli/commands/toggle.py

@@ -0,0 +1,84 @@
+from notee.cli.utils.logs import send_success, send_process, send_error
+from notee.cli.utils.config import get_config, save_config
+from pathlib import Path
+import typer
+
+app = typer.Typer()
+
+@app.command("obsidian_mode")
+def togle_obsidian_mode(
+        on: bool = typer.Option(None, "--on", help="Enable obsidian mode."),
+        off: bool = typer.Option(None, "--off", help="Disable obsidian mode.")
+):
+    """Toggle between creating notes for obsidian or regular md format.
+    --on - Enable obsidian mode
+    --off - Disable obsidian mode
+    """
+    if bool(on) == bool(off):
+        send_error("Use only --on or --off flags please.")
+        return
+    
+    config = get_config()
+
+    if on:
+        config["settings"]["obsidian_mode"] = "y"
+        save_config(config)
+        send_success("Enabled obsidian mode🥳")
+    else:
+        config["settings"]["obsidian_mode"] = "n"
+        save_config(config)
+        send_success("Disabled obsidian mode👌")
+
+@app.command("different_folders")
+def togle_different_folders(
+        on: bool = typer.Option(None, "--on", help="Enable different folders."),
+        off: bool = typer.Option(None, "--off", help="Disable different folders.")
+):
+    """Toggle between creating folder for each tipe of template or store all notes in core folder.
+    --on - Enable different folders.
+    --off - Disable different folders.
+    """
+
+    if bool(on) == bool(off):
+        send_error("Use only --on or --off flags please.")
+        return
+
+    TEMPLATES = ["book", "idea", "movie", "source", "todo"]
+    config = get_config()
+    base_path = config["patches"]["base_folder"]
+
+    if on:
+        for template in TEMPLATES:
+            template_folder_path = Path(f"{base_path}/{template}")
+            template_folder_path.touch()
+            config["patches"][template] = f"{base_path}/{template}"
+            send_success("Enabled different folders. Your notes will be saving into different folders from now.")
+    else:
+        for template in TEMPLATES:
+            config["patches"][template] = base_path
+            send_success("Disabled different folders. Your notes will be saving into base folder from now.")
+    
+    save_config(config)
+
+@app.command("ai_module")
+def togle_different_folders(
+        on: bool = typer.Option(None, "--on", help="Enable different folders."),
+        off: bool = typer.Option(None, "--off", help="Disable different folders.")
+):
+    """Toggle between using ai module and not.
+    --on - Enable ai module.
+    --off - Disable ai module.
+    """
+    if bool(on) == bool(off):
+        send_error("Use only --on or --off flags please.")
+        return
+    
+    config = get_config()
+    if on:
+        config["settings"]["AI_module"] = "y"
+        send_success("Your AI module is on now. Please don't forget to use <notee setup_ai> if you haven't yet.")
+    else:
+        config["settings"]["AI_module"] = "n"
+        send_success("Your AI module is off now. Use <notee ai_module --on> to turn it on again.")
+    
+    save_config(config)

notee-0.1.0/notee/cli/utils/config.py

@@ -0,0 +1,24 @@
+from pathlib import Path
+import configparser
+import typer
+
+
+
+def get_config() -> configparser.ConfigParser:
+    config = configparser.ConfigParser()
+    app_dir = typer.get_app_dir("notee")
+    config_path = Path(app_dir) / "config.ini"
+
+    if not config_path.exists():
+        raise FileNotFoundError("Can't find config. Please use <notee setup> to create it.")
+
+    config.read(config_path, encoding="utf-8")
+    return config
+
+
+def save_config(config: configparser.ConfigParser) -> None:
+    app_dir = typer.get_app_dir("notee")
+    config_path = Path(app_dir) / "config.ini"
+    
+    with open(config_path, "w", encoding="utf-8") as configfile:
+        config.write(configfile)

notee-0.1.0/notee/cli/utils/disk_operations.py

@@ -0,0 +1,13 @@
+from pathlib import Path
+import typer
+
+def is_folder_exists(path):
+    return Path(path).is_dir()
+
+def create_config_file() -> str:
+    app_dir = typer.get_app_dir("notee")
+    config_path = Path(app_dir) / "config.ini"
+    config_path.parent.mkdir(parents=True, exist_ok=True)
+    Path.touch(config_path)
+
+    return config_path

notee-0.1.0/notee/cli/utils/logs.py

@@ -0,0 +1,18 @@
+from rich.text import Text
+from rich import print
+
+def send_success(text) -> None:
+    message = Text(text, style="bold spring_green1")
+    print(message)
+
+def send_warning(text) -> None:
+    message = Text(text, style="bold orange1")
+    print(message)
+
+def send_error(text) -> None:
+    message = Text(text, style="bold deep_pink1")
+    print(message)
+
+def send_process(text) -> None:
+    message = Text(text, style="italic slate_blue1")
+    print(message)

notee-0.1.0/notee/cli/utils/process_text.py

@@ -0,0 +1,38 @@
+from notee.cli.utils.config import get_config
+import re
+
+def process_tags(tags: str):
+    config = get_config()
+    obsidian = config["settings"]["obsidian_mode"]
+    
+    separated = tags.split(" ")
+    result = "Tags: "
+    for tag in separated:
+        if obsidian == "y":
+            result += f" - [[{tag}]]"
+        else:
+            result += f"#{tag} "
+    
+    return result
+
+def process_links(links: str):
+    separated = links.split(" ")
+    result = ""
+    for link in separated:
+        result += f"{link} \n"
+    
+    return result
+
+def process_if_exists(cond, text):
+    if cond:
+        return text
+    return ""
+
+def convert_obsidian_tags(text):
+    pattern = r"\[\[(.*?)\]\]"
+
+    def replace_with_hash(match):
+        tag = match.group(1).strip()
+        return f"#{tag}"
+
+    return re.sub(pattern, replace_with_hash, text)

notee-0.1.0/notee/cli/utils/scaner.py

@@ -0,0 +1,25 @@
+from notee.db.add_file import add_file_to_db
+from notee.db.get_file_patches import get_file_pathes
+import os
+
+def add_from_file(path):
+    with open(path, "r", encoding="utf-8") as file:
+        text = file.read()
+        add_file_to_db(text, path)
+        file.close()
+
+def scan(folder_path: str):
+    names = get_file_pathes()
+    n_new_files = 0
+    with os.scandir(folder_path) as directory:
+        for entity in directory:
+            if entity.is_dir():
+                n_new_files += scan(entity.path)
+            else:
+                if entity.path not in names:
+                    add_from_file(entity.path)
+                    n_new_files += 1
+    return n_new_files
+
+
+    

notee-0.1.0/notee/cli/utils/view_md.py

@@ -0,0 +1,17 @@
+from notee.cli.utils.process_text import convert_obsidian_tags
+from rich.console import Console
+from rich.markdown import Markdown
+
+def view_md_file(path):
+    console = Console()
+    custom_theme = {
+        "markdown.header": "bold magenta",
+        "markdown.code": "italic cyan",
+        "markdown.item": "yellow",
+    }
+
+    with open(path, "r", encoding="utf-8") as f:
+        text = f.read()
+    text = convert_obsidian_tags(text)
+    markdown = Markdown(text, justify="left", code_theme="dracula")
+    console.print(markdown)

notee-0.1.0/notee/db/add_file.py

@@ -0,0 +1,13 @@
+from notee.cli.utils.config import get_config
+import chromadb
+import uuid
+
+def add_file_to_db(text: str, path: str, created_at = ""):
+    config = get_config()
+    db_path = config["settings"]["db_path"]
+    client = chromadb.PersistentClient(db_path)
+    collection = client.get_collection("notee")
+    collection.add(ids=str(uuid.uuid4()), documents=[text], metadatas=[{
+        "path": path,
+        "created_at": created_at
+    }])

notee-0.1.0/notee/db/create_db.py

@@ -0,0 +1,5 @@
+import chromadb
+
+def create_db(path):
+    client = chromadb.PersistentClient(path)
+    collection = client.get_or_create_collection("notee")

notee-0.1.0/notee/db/get_file_patches.py

@@ -0,0 +1,16 @@
+from notee.cli.utils.config import get_config
+import chromadb
+
+def get_file_pathes() -> list:
+    config = get_config()
+    db_path = config["settings"]["db_path"]
+    client = chromadb.PersistentClient(db_path)
+    collection = client.get_collection("notee")
+    result = collection.get(include=["metadatas"], limit=10000)
+    pathes = []
+    for metadata in result["metadatas"]:
+        pathes.append(metadata["path"])
+
+    return pathes
+
+

notee-0.1.0/notee/db/query.py

@@ -0,0 +1,30 @@
+from notee.cli.utils.config import get_config
+import chromadb
+
+
+def search_in_db(query: str) -> list:
+    config = get_config()
+    db_path = config["settings"]["db_path"]
+    client = chromadb.PersistentClient(db_path)
+    collection = client.get_collection("notee")
+    result = collection.query(query_texts=query, n_results=3)
+    
+    responce = []
+    for metadata in result["metadatas"][0]:
+        path = metadata["path"]
+        responce.append(path)
+    
+    return responce
+
+def get_context_for_ai(query: str) -> str:
+    config = get_config()
+    db_path = config["settings"]["db_path"]
+    client = chromadb.PersistentClient(db_path)
+    collection = client.get_collection("notee")
+    result = collection.query(query_texts=query, n_results=5)
+    context = ""
+    for document in result["documents"][0]:
+        context += document
+
+    return context
+

notee-0.1.0/notee/main.py

@@ -0,0 +1,35 @@
+from notee.cli.commands.create_book import app as book_app
+from notee.cli.commands.create_idea import app as idea_app
+from notee.cli.commands.create_movie import app as movie_app
+from notee.cli.commands.create_source import app as source_app
+from notee.cli.commands.create_todo import app as todo_app
+from notee.cli.commands.setup import app as setup_app
+from notee.cli.commands.search import app as search_app
+from notee.cli.commands.toggle import app as togle_app
+from notee.cli.commands.scan import app as scan_app
+from notee.cli.commands.open import app as open_app
+from notee.cli.commands.ask import app as ask_app
+from notee.cli.commands.change_ai_model import app as ai_model_app
+from notee.cli.commands.change_ai_setup import app as ai_setup_app
+from typer import Typer
+
+app = Typer()
+
+app.add_typer(setup_app)
+app.add_typer(book_app)
+app.add_typer(idea_app)
+app.add_typer(movie_app)
+app.add_typer(source_app)
+app.add_typer(todo_app)
+app.add_typer(search_app)
+app.add_typer(scan_app)
+app.add_typer(open_app)
+app.add_typer(togle_app)
+app.add_typer(ask_app)
+app.add_typer(ai_setup_app)
+app.add_typer(ai_model_app)
+
+
+
+if __name__ == "__main__":
+    app()

notee-0.1.0/notee/templates/book.py

@@ -0,0 +1,27 @@
+from notee.cli.utils.process_text import process_tags, process_if_exists
+from notee.cli.utils.config import get_config
+from mdutils.fileutils.fileutils import MarkDownFile
+from datetime import datetime
+
+def create_book_note(title: str, author: str = None, notes: str = None, tags: str = None, rating: int = None):
+    date = datetime.now().strftime("%Y-%m-%d %H:%M")
+    data = f"""
+{date}
+{process_tags(tags) if tags else ""}
+
+# {title}
+
+{process_if_exists(author, f"By **{author}**")}
+
+## Notes
+
+{process_if_exists(notes, notes)}
+
+{process_if_exists(rating, f"**{rating}/10⭐**")}
+"""
+    config = get_config()
+    file = MarkDownFile(name=title, dirname=config["patches"]["book"])
+    file.append_end(data)
+
+    return [data, f"{config["patches"]["book"]}/{title}.md", date]
+

notee-0.1.0/notee/templates/idea.py

@@ -0,0 +1,20 @@
+from notee.cli.utils.process_text import process_tags
+from mdutils.fileutils.fileutils import MarkDownFile
+from notee.cli.utils.config import get_config
+from datetime import datetime
+
+def create_idea_note(title, description: str = None, tags: str = None):
+    date = datetime.now().strftime("%Y-%m-%d %H:%M")
+    data = f"""
+{date}
+{process_tags(tags) if tags else ""}
+
+# {title}
+
+{description}
+"""
+    config = get_config()
+    file = MarkDownFile(name=title, dirname=config["patches"]["idea"])
+    file.append_end(data)
+
+    return [data, f"{config["patches"]["idea"]}/{title}.md", date]

notee-0.1.0/notee/templates/movie.py

@@ -0,0 +1,23 @@
+from notee.cli.utils.process_text import process_tags, process_if_exists
+from notee.cli.utils.config import get_config
+from mdutils.fileutils.fileutils import MarkDownFile
+from datetime import datetime
+
+def create_movie_note(title: str, notes: str = None, tags: str = None, rating: int = None):
+    date = datetime.now().strftime("%Y-%m-%d %H:%M")
+    data = f"""
+{date}
+{process_tags(tags) if tags else ""}
+
+# {title}
+
+{process_if_exists(notes, notes)}
+
+{process_if_exists(rating, f"**{rating}/10⭐**")}
+"""
+    config = get_config()
+    file = MarkDownFile(name=title, dirname=config["patches"]["movie"])
+    file.append_end(data)
+
+    return [data, f"{config["patches"]["movie"]}/{title}.md", date]
+

notee-0.1.0/notee/templates/source.py

@@ -0,0 +1,25 @@
+from notee.cli.utils.process_text import process_tags, process_if_exists, process_links
+from notee.cli.utils.config import get_config
+from mdutils.fileutils.fileutils import MarkDownFile
+from datetime import datetime
+
+def create_source_note(title: str, notes: str = None, tags: str = None, links: str = None):
+    date = datetime.now().strftime("%Y-%m-%d %H:%M")
+    data = f"""
+{date}
+{process_tags(tags) if tags else ""}
+
+# {title}
+
+{process_if_exists(notes, notes)}
+
+## Links
+
+{process_links if links else ""}
+"""
+    config = get_config()
+    file = MarkDownFile(name=title, dirname=config["patches"]["source"])
+    file.append_end(data)
+
+    return [data, f"{config["patches"]["source"]}/{title}.md", date]
+

notee-0.1.0/notee/templates/todo.py

@@ -0,0 +1,20 @@
+from notee.cli.utils.process_text import process_tags
+from mdutils.fileutils.fileutils import MarkDownFile
+from notee.cli.utils.config import get_config
+from datetime import datetime
+
+def create_todo_note(title, description: str = None, tags: str = None):
+    date = datetime.now().strftime("%Y-%m-%d %H:%M")
+    data = f"""
+{date}
+{process_tags(tags) if tags else ""}
+
+# {title}
+
+{description}
+"""
+    config = get_config()
+    file = MarkDownFile(name=title, dirname=config["patches"]["todo"])
+    file.append_end(data)
+
+    return [data, f"{config["patches"]["todo"]}/{title}.md", date]

notee-0.1.0/pyproject.toml

@@ -0,0 +1,23 @@
+[project]
+name = "notee"
+version = "0.1.0"
+description = "Python CLI to create md files with terminal in seconds"
+readme = "README.md"
+license = {file = "LICENSE"}
+requires-python = ">=3.12, <3.14.2"
+dependencies = [
+    "mdutils>=1.8.1",
+    "typer>=0.24.1",
+    "chromadb>=1.5.2",
+    "InquirerPy>=0.3.4",
+    "openai>=2.26.0",
+    "google-genai>=1.66.0",
+    "openrouter>=0.7.11"
+]
+
+[project.scripts]
+notee = "notee.main:app"
+
+[build-system]
+requires = ["flit_core<4"]
+build-backend = "flit_core.buildapi"