taskai-cli 0.1.3__py3-none-any.whl

taskai/cli.py

@@ -0,0 +1,312 @@
+# standard lib
+import argparse
+import os
+from datetime import datetime
+import builtins
+
+# local
+from taskai.json_dir_database import JsonDirectoryDatabase
+from taskai.views import view_lists, view_item, view_items
+from taskai.models import Base, TodoItem, TodoList, Comment
+from taskai.services.ai import ai_headstart_service, ai_natural_language_service
+from taskai.services.user_setup import user_setup_service
+from taskai.help_menu import help_menu
+from taskai.config import GlobalConfig
+
+# external
+from rich import print
+
+# config
+DB_PATH = ".taskai/task_db"
+USER = os.getenv("USER")
+db = JsonDirectoryDatabase(
+        DB_PATH,
+        USER
+)
+db.connect()
+
+og_help = builtins.help
+def new_help(*args, **kwargs):
+    print(f"help: args: {args}, kwargs: {kwargs}")
+    return og_help(*args, **kwargs)
+builtins.help = new_help
+
+class Controller:
+
+    # utilities
+    def _find_model_by_substring(attr: str, value: str) -> TodoItem|TodoList|Comment|None:
+        for id_ in [*db.lists.keys(),*db.items.keys(),*db.comments.keys()]:
+            model = db.read(id_)
+            if (
+                hasattr(model, attr) and 
+                isinstance(getattr(model, attr), str) and 
+                value in getattr(model, attr)
+            ):
+                return model
+        
+        return None
+
+
+    def _debug(args, kwargs):
+        print("args:", args)
+        print("kwargs:", kwargs)
+
+    # CRUD
+    def show_all(show_done=False):
+        view_lists(db, db.lists, show_done=show_done)
+    
+    def show_by_id(id_, show_done=False):
+        if id_ in db.items:
+            Controller.show_item(id_)
+        elif id_ in db.lists:
+            Controller.show_list(id_, show_done=show_done)
+    
+    def show_by_list_name(value: str, show_done=False):
+        model = Controller._find_model_by_substring("name", value)
+        if isinstance(model, TodoList):
+            Controller.show_list(model.id, show_done=show_done)
+        else:
+            print(f"Could not find list with substring '{value}'")
+
+    def show_list(list_id: int|str, show_done=False):
+        view_lists(db, [list_id], show_done=show_done)
+    
+    def show_item(item_id: int|str):
+        view_item(db, item_id)
+
+    def show_items(item_ids: str):
+        item_ids = item_ids.split(",")
+        view_items(db, item_ids)
+    
+    def show_examples():
+        ...
+        print("Not implemented yet")
+
+    def create_list(name: str):
+        list = TodoList(name=name)
+        list_id = db.create(list)
+        db.commit()
+        print(f"Creating list {list_id} - {list.name}")
+
+    def create_item(list_id: int|str, title: str, **kwargs):
+        try:
+            int(list_id)
+        except ValueError:
+            list_ = Controller._find_model_by_substring("name", list_id)
+            # TODO this should be just lists, not models
+            list_id = list_.id
+
+        item = TodoItem(title=title, list_id=list_id)
+
+        for k, v in kwargs.items():
+            if v is None:
+                continue
+            match k:
+                case "completed": item.completed = bool(v)
+                case "description": item.description = str(v)
+                case "due_by": item.due_by = datetime.strptime(v, "%Y-%m-%d")
+                case "parent": item.parent = str(v)
+                case "priority": item.priority = int(v)
+                case "depends_on": item.dependency_ids.extend(v.split(","))
+                # TODO handle recurrence
+        db.create(item)
+        db.commit()
+
+    def create_comment(item_id: int|str, content: str):
+        comment = Comment(
+            item_id=item_id,
+            content=content
+        )
+        db.create(comment)
+        db.commit()
+            
+    def update_item(item_id: int|str, **kwargs):
+        item: TodoItem = db.read(item_id)
+        for k, v in kwargs.items():
+            if v is None:
+                continue
+            match k:
+                case "title": item.title = str(v)
+                case "list_id": item.list_id = str(v)
+                case "completed": item.completed = bool(v)
+                case "description": item.description = str(v)
+                case "due_by": item.due_by = datetime.strptime(v, "%Y-%m-%d")
+                case "parent": item.parent = str(v)
+                case "priority": item.priority = int(v)
+                # TODO handle recurrence
+
+        db.update(item)
+        db.commit()
+
+    def delete(id_: int|str):
+        db.delete(id_)
+        db.commit()
+        print(f"Deleted {id_}")
+    
+    def delete_completed():
+        for item_id in db.items.copy():
+            item: TodoItem = db.read(item_id)
+            if item.completed:
+                db.delete(item_id)
+        db.commit()
+    
+    def ai_headstart(item_id: int|str):
+        ai_response_text = ai_headstart_service(db, item_id)
+        comment_content = f"AI: {ai_response_text}"
+        Controller.create_comment(item_id, comment_content)
+        print(comment_content)
+
+    def ai_natural_language(prompt: str):
+        ai_natural_language_service(db, prompt)
+    
+    def throw_error(error_description: str, *args, **kwargs):
+        print(f"[red]ERROR: {error_description}[/red]\nargs={args}\nkwargs={kwargs}")
+    
+    def get_config_value(key: str):
+        print(db.get_config_value(key))
+    
+    def list_config():
+        for k, v in db.get_config().items():
+            print(f"{k}={v}")
+    
+    def set_config_value(key: str, value: any):
+        db.set_config_value(key, value)
+        db.commit()
+        print(f"setting {key}={value}")
+    
+    def remove_config_value(key: str):
+        db.config.pop(key)
+        db.commit()
+    
+    def run_setup_service():
+        user_setup_service(db)
+
+# utilities
+def _parse_remaining(remaining_args: list[str]) -> tuple[list, dict]:
+
+    for i, _arg in enumerate(remaining_args):
+        remaining_args[i] = _arg.replace(" ", "+-*/")
+    remaining_args = " ".join(remaining_args).replace("="," ").split(" ")
+    for i, _arg in enumerate(remaining_args):
+        remaining_args[i] = _arg.replace("+-*/", " ")
+    
+    # outputs
+    args = []
+    kwargs = {}
+
+    while remaining_args:
+        next_arg = remaining_args.pop(0)
+        if next_arg.startswith("--"):
+            assert remaining_args, "kwarg specified with no value provided"
+            kwargs[next_arg[2:]] = remaining_args.pop(0)
+        else:
+            args.append(next_arg)
+    
+    return args, kwargs
+
+def _is_int(val: any) -> bool:
+    try:
+        int(val)
+        return True
+    except:
+        return False
+
+def _matches_string(val: str, target: str) -> bool:
+    # TODO make this follow linux rules
+    if val in target:
+        return True
+    return False
+
+
+
+def entry_point():
+
+    arg_parser = argparse.ArgumentParser()
+    _, argv = arg_parser.parse_known_args()
+
+
+    if not argv:
+        print(help_menu["general"])
+        return
+
+    if argv[0] in ("help","--help"):
+        print(help_menu["general"])
+        return
+
+    args, kwargs = _parse_remaining(argv)
+    GlobalConfig.load_dict(db.config)
+
+    try:
+        match args[0]:
+            case "setup":
+                Controller.run_setup_service()
+
+            case "show":
+                match args[1]:
+                    case "all": Controller.show_all(*args[2:], **kwargs)
+                    case "list": Controller.show_list(*args[2:], **kwargs) 
+                    case "item": Controller.show_item(*args[2:], **kwargs)
+                    case "items": Controller.show_item(*args[2:], **kwargs)
+                    case "examples": Controller.show_examples()
+                    case _ if _is_int(args[1]): Controller.show_by_id(*args[1:], **kwargs)
+                    case _: Controller.show_by_list_name(args[1], **kwargs)
+
+            case "create":
+                match args[1]:
+                    case "item": Controller.create_item(*args[2:], **kwargs)
+                    case "list": Controller.create_list(*args[2:], **kwargs)
+                    case "comment": Controller.create_comment(*args[2:], **kwargs)
+                    case _: Controller.throw_error("uncrecognized create command", *args, **kwargs)
+            
+            case "update":
+                match args[1]:
+                    case _ if _is_int(args[1]): Controller.update_item(args[1], **kwargs)
+                    case _: Controller.throw_error("uncregnozed update command", *args, **kwargs)
+
+            case "delete" | "remove":
+                match args[1]:
+                    case _ if _is_int(args[1]): Controller.delete(args[1])
+                    case "item": Controller.delete(args[2])
+                    case "list": Controller.delete(args[2])
+                    case "completed" | "done": Controller.delete_completed()
+                    case _: Controller.throw_error("unrecognized delete command", *args, **kwargs)
+
+            case "comment":
+                match args[1]:
+                    case _ if _is_int(args[1]): Controller.create_comment(*args[1:], **kwargs)
+            
+            case "config":
+                match args[1]:
+                    case "set": Controller.set_config_value(key=args[2], value=args[3])
+                    case "get": Controller.get_config_value(key=args[2])
+                    case "list"|"show": Controller.list_config()
+                    case "pop": Controller.remove_config_value(key=args[2])
+                    case _: Controller.throw_error("unrecognized command", *args, **kwargs)
+            
+            case "ai":
+                match args[1]:
+                    case "headstart": Controller.ai_headstart(*args[2:], **kwargs)
+                    case _: Controller.ai_natural_language(" ".join(args[1:]))
+
+            case "nuke":
+                db.remove()
+            
+            case "add":
+                Controller.create_item(*args[1:], **kwargs)
+
+            case "complete" | "done":
+                match args[1]:
+                    case _ if _is_int(args[1]): Controller.update_item(args[1], completed=True)
+                    case _: Controller.throw_error("unrecognized complete command", *args, **kwargs)
+
+            case "examples":
+                Controller.show_examples()
+
+            case _: Controller.throw_error("unrecognized command", *args, **kwargs)
+    except Exception as e: 
+        Controller.throw_error(f"encountered exception '{e}'", *args, **kwargs)
+
+
+
+if __name__ == "__main__":
+    entry_point()

taskai/config.py

@@ -0,0 +1,36 @@
+
+
+class GlobalConfig:
+    """Global store for configuration values"""
+
+
+    _data_store: dict[str, any]
+
+    @classmethod
+    def load_dict(cls, d: dict):
+        """loads values from a configuration"""
+        cls._data_store = d
+
+    @classmethod
+    def get(cls, key: str):
+        """Gets a value from a configuration"""
+        if key not in cls._data_store:
+            return None
+        return cls._data_store[key]
+
+    @classmethod
+    def set(cls, key: str, value: any):
+        cls._data_store[key] = value
+
+        
+
+def config(config_key: str, kwarg_name: str):
+    def decorator(fn):
+        def inner(*args, **kwargs):
+            kwargs[kwarg_name] = GlobalConfig.get(config_key)
+            result = fn(*args, **kwargs)
+            return result
+        return inner
+    return decorator
+
+

taskai/help_menu.py

@@ -0,0 +1,35 @@
+
+
+
+help_general = """
+
+Welcome to Task! Here's what you can do:
+
+'task show all' --> show all of your lists and item titles, with their respective IDs prepended
+'task show {id or substring}' --> find the list or item matching your identifier and show it using its respective type's show command
+'task show list {id or substring}' --> show the list and all of its item titles
+'task show item {id}' --> show the associated item and all of its specified information
+'task show items {id1},{id2},...,{idx}' --> show the associated items and all of their specified information
+'task create item {list id or substring} {title} {**kwargs}' --> Create a new item for the associated list. Can specify kwargs as --optional cli arguments. 
+'task create list {name}' --> create a new list by that name
+'task delete {id}' --> deletes the list or item associated with that id
+'task delete item {id}' --> deletes the item associated with that id
+'task delete list {id}' --> deletes the list associated with that id
+'task delete completed' --> deletes all items that have been completed
+'task remove ...' --> aliases directly to 'task delete ...
+'task update {item id} {**kwargs}' --> updates the associated attributes on the item
+'task comment {item id} {content}' --> adds a comment to that items comment thread
+'task ai {prompt}' --> Feeds a prompt directly to an LLM, which constructs and executes a series of task commands according to its interpretation of the prompt
+'task ai headstart {item id}' --> Feeds the item context to an LLM, which responds with a concise description of the next step to perform. The response is added as a comment in the items comment thread
+'task nuke' --> deletes all of your task data, letting you have a fresh start
+'task add ...' -> aliases directly to 'task create item ...'
+'task complete {item id}' --> sets the associated item's .completed attribute to true
+
+Run 'task show examples' to print a comprehensive set of examples, and grep for the ones that you're interested in!
+
+"""
+
+
+help_menu = {
+    "general": help_general,
+}

taskai/json_dir_database.py

@@ -0,0 +1,176 @@
+# standard lib
+import os
+from pathlib import Path
+import shutil
+
+# local
+from taskai.models import *
+
+# external
+import orjson as json
+
+class JsonDirectoryDatabase:
+
+    def __init__(
+            self,
+            dirpath: os.PathLike,
+            user: str
+    ):
+        
+        self.db_dir = Path(dirpath)
+        self.user_name = user
+        self.user_data_path = Path(dirpath) / (user.strip(" ") + ".json")
+        self.user_data = None
+
+        if not os.path.exists(self.db_dir):
+            self._setup_directory()
+        
+        if not os.path.exists(self.user_data_path):
+            self._setup_user_data()
+    
+    def remove(self):
+        if os.path.exists(self.db_dir):
+            shutil.rmtree(self.db_dir)
+
+    # setup utils
+    def _setup_directory(self):
+        os.makedirs(self.db_dir, exist_ok=True)
+
+    def _setup_user_data(self):
+        user_data = User(
+            id="0",
+            name=self.user_name
+        ).model_dump()
+
+        user_data[TodoList.__name__] = {}
+        user_data[TodoItem.__name__] = {}
+        user_data[Comment.__name__] = {}
+        user_data["config"] = {}
+
+        self.user_data = user_data
+        self.commit()
+
+    # data accessors
+    @property
+    def lists(self) -> dict:
+        return self.user_data[TodoList.__name__]    
+    
+    @property
+    def items(self) -> dict:
+        return self.user_data[TodoItem.__name__]
+
+    @property
+    def comments(self) -> dict:
+        return self.user_data[Comment.__name__]
+    
+    @property
+    def user_id(self):
+        return self.user_data["id"]
+    
+    @property
+    def config(self) -> dict:
+        return self.user_data["config"]
+
+    # io
+    def connect(self):
+        with open(self.user_data_path, "rb") as f:
+            json_bstring = f.read()
+            self.user_data = json.loads(json_bstring)
+
+    def commit(self):
+        with open(self.user_data_path, "wb") as f:
+            json_bstring = json.dumps(self.user_data)
+            f.write(json_bstring)
+    
+    def flush(self):
+        self.user_data = None
+    
+    def close(self):
+        self.flush()
+    
+    # crud
+    def create(self, record: Base) -> int:
+
+        record.id = str(self.user_data["id_counter"])
+        record.user_id = self.user_id
+
+        if isinstance(record, TodoList):
+            self.lists[record.id] = record.model_dump()
+
+        elif isinstance(record, TodoItem):
+            self.items[record.id] = record.model_dump()
+            self.lists[record.list_id]["item_ids"].append(record.id)
+        
+        elif isinstance(record, Comment):
+            self.comments[record.id] = record.model_dump()
+            self.items[record.item_id]["comment_ids"].append(record.id)
+        else:
+            raise RuntimeError("don't know what you're creating")
+        
+        self.user_data["id_counter"] += 1
+        return record.id
+    
+    def read(self, id_: int|str) -> Base:
+        id_ = str(id_)
+        if id_ in self.user_data[TodoList.__name__]:
+            return TodoList(**self.lists[id_])
+        elif id_ in self.user_data[TodoItem.__name__]:
+            return TodoItem(**self.items[id_])
+        elif id_ in self.user_data[Comment.__name__]:
+            return Comment(**self.comments[id_])
+        else:
+            raise RuntimeError("Can't find record to read")
+
+    def update(self, record: Base) -> None:
+            
+        if isinstance(record, TodoItem):
+
+            assert record.id in self.items, "item doesn't exist"
+            
+            # update dependencies
+            old_item: TodoItem = self.items[record.id]
+            if old_item["list_id"] != record.list_id:
+                old_list: TodoList = self.read(old_item["list_id"])
+                old_list.item_ids.remove(record.id)
+                new_list: TodoList = self.read(record.list_id)
+                new_list.item_ids.append(record.id)
+
+            self.items[record.id] = record.model_dump()
+        
+        else:
+            raise RuntimeError("don't know what you're creating")
+        
+    def delete(self, id_: int|str) -> None:
+        id_ = str(id_)
+        if id_ in self.user_data[TodoList.__name__]:
+            list_: TodoList = TodoList(**self.lists.pop(id_))
+            for item_id in list_.item_ids:
+                self.items.pop(item_id)
+        elif id_ in self.user_data[TodoItem.__name__]:
+            item: TodoItem = TodoItem(**self.items.pop(id_))
+            self.lists[item.list_id]["item_ids"].remove(id_)
+        elif id_ in self.user_data[Comment.__name__]:
+            comment: Comment = Comment(**self.comments.pop(id_))
+            self.items[comment.item_id].comment_ids.remove(id_)
+        else:
+            raise RuntimeError("Don't know what you're deleting")
+    
+
+    # Utilities
+    def get_list_by_name(self, name: str):
+        for list_id in self.lists:
+            list_: TodoList = self.read(list_id)
+            if list_.name.lower() == name.lower():
+                return list_
+        raise RuntimeError("Don't recognize list")
+
+
+    # Config
+    def get_config_value(self, key: str) -> any:
+        return self.user_data["config"].get(key)
+
+    def get_config(self) -> dict:
+        return self.user_data.get("config", {})
+
+    def set_config_value(self, key: str, value: any):
+        self.user_data["config"][key] = value

taskai/models.py

@@ -0,0 +1,57 @@
+# standard lib
+from dataclasses import dataclass
+from typing import Optional
+from datetime import datetime, timedelta
+
+# external
+from pydantic import Field, BaseModel
+
+class Base(BaseModel):
+    pass
+
+@dataclass
+class PostgresConfig:
+    pass
+
+class User(Base):
+    id: Optional[str] = Field(default=None, primary_key=True)
+    name: str
+    
+    id_counter: int = 1
+    # password stuff
+
+class TodoList(Base):
+    name: str
+
+    id: Optional[str] = Field(default=None, primary_key=True)
+    user_id: Optional[str] = None
+    item_ids: Optional[list[str]] = Field(default_factory=list)
+
+class TodoItem(Base):
+    title: str = Field(index=True)
+
+    id: Optional[str] = Field(default=None, primary_key=True)
+    list_id: Optional[str] = None
+    user_id: Optional[str] = None
+    created_on: datetime = Field(default_factory=datetime.now)
+    completed: bool = False
+    description: str = ""
+    due_by: Optional[datetime] = None
+    parent: Optional[str] = None
+    comment_ids: list[str] = Field(default_factory=list)
+    dependency_ids: list[str] = Field(default_factory=list)
+    priority: int = 0
+    recurs_every: Optional[list[timedelta]] = None
+    recurs_until: Optional[datetime] = None 
+    recur_keep_incomplete: bool = False
+    
+class Comment(Base):
+    content: str
+
+    item_id: Optional[str] = None
+    id: Optional[str] = Field(default=None, primary_key=True)
+    user_id: Optional[str] = None
+    created_on: datetime = Field(default_factory=datetime.now)
+
+class LLMConfig(Base):
+    pass

taskai/services/ai.py

@@ -0,0 +1,179 @@
+"""
+This file defines services for calling an LLM.
+
+All services are idempotent
+"""
+# standard lib
+import json
+
+# local
+from taskai.json_dir_database import JsonDirectoryDatabase
+from taskai.models import TodoItem, TodoList, Comment
+from taskai.config import config
+from taskai.help_menu import help_general
+
+@config("GEMINI_API_KEY", "api_key")
+@config("GEMINI_MODEL", "model_name")
+def ai_headstart_service(
+        db: JsonDirectoryDatabase,
+        item_id: str,
+        api_key: str,
+        model_name: str
+):
+    """
+    This service queries an LLM for your task and asks it to give you
+    a headstart on a given task. It will perform the following operations:
+
+    - Compile the context for the query, including task description, dependencies
+    and previous comments
+    - Query the LLM
+    - Parse and return its response
+    """
+
+
+    item:TodoItem = db.read(item_id)
+
+    
+    from google import genai
+    
+
+
+    # contruct prompt
+    prompt = f"""
+Hi Gemini, you're job is to provide a very succinct headstart for a taskai item.
+This will involve the following:
+- parsing the task information, including description, comments and dependencies
+- performing any necessary internet searches in order to acquire relevant information
+- deciding on what the next immediate step to be taken is
+- returning a very succinct command to the user, with the information necessary to execute that command
+
+
+Examples of good responses:
+
+"Call the florist: 443-869-2158"
+"Email HR @ hr@comapany.com 'Hi, I won't be able to make it in today'"
+"Write the natural language service interface:\ndef natural_language_service(db:):\n\t..."
+
+These should be short and to the point. Your response should contain NOTHING but the comment for the user.
+
+Here's the relevant information:
+
+task title: {item.title}
+"""
+
+    if item.description:
+        prompt += f"\ntask description: {item.description}"
+    if item.comment_ids:
+
+        prompt += f"\ntask comments:"
+        for comment_id in item.comment_ids:
+            comment: Comment = db.read(comment_id)
+            prompt += f"\n\t- {comment.content}"
+
+    # return "Survey says go fuck yourself"
+
+    # query model
+    client = genai.Client(api_key=api_key)
+    response = client.models.generate_content(
+        model=model_name,
+        contents=prompt
+    )
+
+    return response.text
+
+@config("GEMINI_API_KEY", "api_key")
+@config("GEMINI_MODEL", "model_name")
+def ai_natural_language_service(
+    db: JsonDirectoryDatabase,
+    prompt: str,
+    api_key: str,
+    model_name: str
+):
+    """
+    This service queries an LLM with a natural language
+    prompt from the user. The response is a series of terminal commands
+    called directly
+    """
+    print(f"Ai prompt: {prompt}")
+    
+    # build user info
+    user_info = []
+    for id_ in db.lists:
+        list: TodoList = db.read(id_)
+        user_info.append(f"{list.id} {list.name}")
+        for item_id in list.item_ids:
+    
+            item: TodoItem = db.read(item_id)
+            if not item.completed:
+                user_info.append(f"\t {item.id} {item.title}")
+    user_info = "\n".join(user_info)
+
+    # build ai prompt
+    ai_prompt = f"""
+You are a todo-list agent. Your job is to convert a natural language description from a user into a set
+of CLI operations using our app. Here are a comprehensive list of operations that can be performed
+
+{help_general}
+
+Here are all of the user's list and task titles, each prepended with their id
+
+{user_info}
+
+Here is the user's prompt: 
+
+{prompt}
+"""
+    
+    ai_prompt += """
+Your response should be a JSON output with a valid list of commands, as specified by the description above.
+Each command should be structured in the following format:
+    {
+        "command": ... -> the subcommand you want to use (omit the first 'task' here)
+        "args": [...] -> the positional arguments to use
+        "kwargs": {"..." : "...", ...} -> the keyword arguments to use. All keyword argument names should be prepended with '--' 
+    }
+
+Here is an example of a response that you could return:
+
+```
+[
+    {
+        "command": "add",
+        "args": ["Daily", "Take out the trash"],
+        "kwargs": {"--description": "some description"}
+    },
+    {
+        "command": "add",
+        "args": ["Daily", "Walk the dog"]
+    },
+    {
+        "command": "delete",
+        "args": ["Old Daily List"]
+    }
+]
+```
+
+It is ABSOLUTELY IMPERATIVE that your response be valid json, as your output is going to be parsed directly. Return NOTHING but the json output.
+
+"""
+
+    
+    from google import genai
+
+    print(ai_prompt)
+    client = genai.Client(api_key=api_key)
+    response = client.models.generate_content(
+        model=model_name,
+        contents=prompt
+    )
+
+    try:
+        response_json = json.loads(response.text)
+        print(response_json)
+    except json.JSONDecodeError:
+        print(response.text)
+        print("\n\ndecode error")
+        import sys
+        sys.exit(-1)
+
+        

taskai/services/user_setup.py

@@ -0,0 +1,63 @@
+"""
+This service will handle user setup and configuration
+
+Basically, we're going to have a set of steps that we're going to iterate through
+"""
+from taskai.json_dir_database import JsonDirectoryDatabase
+
+from rich.prompt import Prompt
+from rich import print
+import os
+
+
+def user_setup_service(
+    db: JsonDirectoryDatabase
+):
+    
+    config = db.config
+    # setup gemini model
+    print("Beginning setup")
+    if "GEMINI_API_KEY" not in config:
+        api_key = _get_gemini_api_key()
+        if api_key:
+            config["GEMINI_API_KEY"] = api_key
+    else:
+        print("gemini key already specified")
+    
+    if "GEMINI_MODEL" not in config:
+        model = _select_gemini_model()
+        if model:
+            config["GEMINI_MODEL"] = model
+    else:
+        print("gemini model already specified")
+    print("Setup complete! Use 'task config set|get|list' to interact with your configuration options")
+    db.commit()
+
+def _get_gemini_api_key() -> str|None:
+    response = Prompt.ask("Please enter your Gemini API key (use '$--' to access env vars)")
+    
+    if response.startswith("$"):
+        response = os.getenv(response[1:])
+    if not response:
+        return
+    print(f"Storing: [green]{response}[/green]")
+    return response
+
+
+def _select_gemini_model():
+    response = Prompt.ask(
+        "Please select which Gemini model you would like:",
+        choices=[
+            "gemini-3.5-flash"
+        ]
+    )
+    return response
+
+
+if __name__ == "__main__":
+    import os
+    db = JsonDirectoryDatabase(
+        ".taskai/task_db", user=os.getenv("USER")
+    )
+    db.connect()
+    user_setup_service(db)

taskai/views.py

@@ -0,0 +1,93 @@
+# local
+from taskai.json_dir_database import JsonDirectoryDatabase
+from taskai.models import TodoList, TodoItem, Comment
+
+# external
+from rich import print
+from rich.console import Console
+import rich
+
+
+def view_lists(db: JsonDirectoryDatabase, ids: list[str], show_done=False):
+    """Shows all the lists"""
+
+    
+    for id_ in ids:
+
+        if id_ in db.lists:
+            list: TodoList = db.read(id_)
+        elif isinstance(id_, str):
+            for lid in db.lists:
+                list = db.read(lid)
+                if list.name.lower() == id_.lower():
+                    break
+            else: 
+                raise RuntimeError("cannot match list")
+
+        print(list.id, list.name)
+        for item_id in list.item_ids:
+
+            # silently repair lists with
+            if (item_id not in db.items):
+                list.item_ids.remove(item_id)
+                continue
+                
+            item: TodoItem = db.read(item_id)
+            if not item.completed:
+                print("\t",item.id, item.title)
+            elif show_done:
+                print(f"\t [strike]{item.id} {item.title}[/strike]")
+
+
+def view_item(db: JsonDirectoryDatabase, item: str|TodoItem):
+    """Show details for item"""
+    
+    if isinstance(item, (str,int)):
+        item: TodoItem = db.read(item)
+    console = Console()
+    console.print(f"[bold green]Title:[/bold green] {item.title}")
+    if item.due_by:
+        console.print(f"[bold green]Due By:[/bold green] {item.due_by or ""}")
+    
+    if item.description:
+        console.print(f"\n[bold green]Description:[/bold green]\n{item.description}")
+    
+    if item.dependency_ids:
+        console.print(f"\n[bold green]Depends on:[/bold green]{''.join([
+            f'\n{depend_id} - {db.read(depend_id).title}' for depend_id in item.dependency_ids 
+        ])}")
+
+    if item.comment_ids:
+        console.print("\n[bold green]\nComments:[/bold green]")
+        for comment_id in item.comment_ids:
+            comment: Comment = db.read(comment_id)
+            console.print(f"{comment.created_on.strftime("%Y-%m-%d %H:%M:%S")} - {comment.content}")
+    
+
+def view_items(
+    db: JsonDirectoryDatabase, 
+    ids: list[str],
+    sort_by: str  = "due_by",
+    ascending: bool = False
+):
+    
+    items = {}
+    for id_ in ids:
+        if id_ in db.items:
+            item = db.read(id_)
+            items[id_] = (item)
+        elif id_ in db.lists:
+            list: TodoList = db.read(id_)
+            for item_id in list.item_ids:
+                item = db.read(item_id)
+                items[item_id] = item
+    
+    
+    # sort
+    items = sorted(items.values(), key=lambda item: str(getattr(item, sort_by)), reverse=ascending)
+
+    # view
+    for item in items:
+        rich.console.Console().rule(style="bold white")
+        view_item(db, item)
+        print()

taskai_cli-0.1.3.dist-info/METADATA

@@ -0,0 +1,47 @@
+Metadata-Version: 2.4
+Name: taskai-cli
+Version: 0.1.3
+Author-email: Alex Paskal <alexcpaskal@gmail.com>
+Requires-Python: >=3.12
+Requires-Dist: google-genai>=2.8
+Requires-Dist: orjson>=3.11
+Requires-Dist: pydantic>=2.13
+Requires-Dist: rich>=15
+Description-Content-Type: text/markdown
+
+# Task AI
+
+Welcome to Task AI - a command-line todo list with some extra ai features. 
+
+Here's what you can do:
+
+- `task show all` --> show all of your lists and item titles, with their respective IDs prepended
+- `task show {id or substring}` --> find the list or item matching your identifier and show it using its respective type's show command
+- `task show list {id or substring}` --> show the list and all of its item titles
+- `task show item {id}` --> show the associated item and all of its specified information
+- `task show items {id1},{id2},...,{idx}` --> show the associated items and all of their specified information
+- `task create item {list id or substring} {title} {**kwargs}` --> Create a new item for the associated list. Can specify kwargs as --optional cli arguments. 
+- `task create list {name}` --> create a new list by that name
+- `task delete {id}` --> deletes the list or item associated with that id
+- `task delete item {id}` --> deletes the item associated with that id
+- `task delete list {id}` --> deletes the list associated with that id
+- `task delete completed` --> deletes all items that have been completed
+- `task remove ...` --> aliases directly to 'task delete ...
+- `task update {item id} {**kwargs}` --> updates the associated attributes on the item
+- `task comment {item id} {content}` --> adds a comment to that items comment thread
+- `task ai {prompt}` --> Feeds a prompt directly to an LLM, which constructs and executes a series of task commands according to its interpretation of the prompt
+- `task ai headstart {item id}` --> Feeds the item context to an LLM, which responds with a concise description of the next step to perform. The response is added as a comment in the items comment thread
+- `task nuke` --> deletes all of your task data, letting you have a fresh start
+- `task add ...` -> aliases directly to `task create item ...`
+- `task complete {item id}` --> sets the associated item's .completed attribute to true
+
+Run `task show examples` to print a comprehensive set of examples, and grep for the ones that you're interested in!
+
+
+# Installation
+
+
+# Configuration
+
+
+

taskai_cli-0.1.3.dist-info/RECORD

@@ -0,0 +1,12 @@
+taskai/cli.py,sha256=hXC8Ksp9VsGoCji-yihd0e_cl48K374JN1h7cQ1X4BM,10392
+taskai/config.py,sha256=TJWcIUCvACwSrEQNPm4yIzIu3MfGL4DFlj0LjyO_6As,808
+taskai/help_menu.py,sha256=H91sgHc9pkfe21CPWoijBMLJ93UBpJ3ZGW6wVTupW0Y,2053
+taskai/json_dir_database.py,sha256=5jwzytRimoceXYJ8CEhFSWW9EQnbmAXohyPAqhB0NY4,5292
+taskai/models.py,sha256=PKy2FNNU0r5azO0GBw1RoiW2H9-KY1scaGHvYLrbFlw,1509
+taskai/views.py,sha256=gvd0mt8xTyNJYpn6uzg6r9trZNnOgCrfZA_8cIkluh8,2834
+taskai/services/ai.py,sha256=ZQKii_fU-mUWfSLkiC6y7EIk1pTdNS-Av3o5Fd6uBNc,4950
+taskai/services/user_setup.py,sha256=F68b6aITPI3Ez4yGE6yu3fGRJ7k1tIroLux84Uw7-m8,1627
+taskai_cli-0.1.3.dist-info/METADATA,sha256=dR_ILfRS3vnbfxIct8spMavL_p7VXQJfL8poxiPMlb4,2410
+taskai_cli-0.1.3.dist-info/WHEEL,sha256=mffPy8wBnZQn2VnJUU5jE99KsxaSfiyMHV9Yt0aLVxs,87
+taskai_cli-0.1.3.dist-info/entry_points.txt,sha256=BWVOsXn4B7dsx_uNYjxEmX6YSW_qjCXqwNQVyIqctO4,48
+taskai_cli-0.1.3.dist-info/RECORD,,

taskai_cli-0.1.3.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.30.1
+Root-Is-Purelib: true
+Tag: py3-none-any

taskai_cli-0.1.3.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+task = taskai.cli:entry_point