taskai-cli 0.1.3__tar.gz → 0.1.4__tar.gz

taskai_cli-0.1.4/DEVLOG.md

@@ -0,0 +1,285 @@
+# 6-14
+
+Damn it's been a productive couple of weeks. App is deployed on PyPi and I'm starting to think
+a bit more about phase 2, how to rewrite it for ultimate success. What I'm thinking is that
+things like help, argument patterns, and service logics should be bundled into one unit - 
+
+the core infrastructure should basically load all of the services in the config, and pull their
+argument pattern matching, help menus, etc. That way, the core of the app just works as a dispatcher
+
+Things I need to have clearly in mind before I start rearchitecting:
+- How i'm going to handle modularity and reuse for major components
+- How i'm going to handle multiple threads and processes
+    - a note on this - i'm leaning towards having a core metadata file that just keeps track
+    of all processes, that we just read/write to (with some sort of locking mechanism). That
+    will maintain process ids and any other shared state
+
+But before all that good stuff, let's take what we have and polish the hell out of it
+
+
+Also, as I'm doing this, it's becoming clear to me that I need to have records be a bit
+more object oriented, as the number of different interactions that have to take place is 
+getting more and more annoying to keep track of and the best place for everything to be
+put would be as methods on the objects, i.e. "item.updateList()", etc.
+
+
+# 6-3
+
+Alright so how are comments gonna look here:
+
+    ```
+    Title:
+    Due By:
+    Description:
+    Depends On:
+    Comments
+
+    ```
+
+
+Let's think about what this cli refactor is gonna look like:
+
+
+arg
+    arg
+        ...
+            endpoint, *args, **kwargs
+
+
+
+# 5-28
+
+A couple things that I need to deal with:
+- recursive deletes (so deleting hierarchical items)
+- recursive completes
+- better recurrence strategies
+- how to deal with linking tasks that are recurrence of the same task
+- database server
+
+# 5-27
+
+Let's think about this cli:
+
+what do i want to be able to do?
+
+
+
+
+- task add item|list|comment
+- task show item|list|comment
+- task complete {id}
+- task delete {id}
+- task {id} depends_on {id}
+- task dependency_chain
+
+
+- task {id} delete|done|show|edit
+
+
+Let's start with some views
+
+need to have recursive delete for lists
+
+# 5-26
+
+What can I build right now?
+
+I want to have a basic CLI version of what I want. So we can use a pickle database,
+define our models, and add the basic functionality to the core business logic. 
+
+
+How can we design this?
+
+- I could have a core app session that is built through some composition
+- for different concurrent users, we could spin up different processes?
+    - why don't I worry about scaling when it comes time to scale, let's just build osmething cool and useful right now
+
+- So we have the app session object, and we can spin it up:
+    - on startup
+        - connect to a database
+    - call methods to perform the actions we care about
+        - commit changes as we want
+        OR
+        - have a plugin architecture where we can add views/operations that take in the session object
+    - on exit
+
+CLI version
+    - do I want it to run in the background and communicate via pipes?
+        - feels like that falls under premature optimization, maybe just try running everything at once to start
+        - though that could be fun? maybe next start
+    - maybe not a pickle database, can do a local folder json database
+
+
+
+so:
+    Session:
+        def __init__(
+            user: User,
+            database: Database
+        )
+
+        def on_exit():
+            ...
+
+    cli/
+        views/       --> views of the core data
+        services/    --> core business operations we can perform
+        cli.py
+
+
+
+
+
+        
+
+
+
+
+
+# 5-11
+
+Alright let's think about backend
+
+What is the point of this app? What do I want to be able to support?
+- 
+
+
+
+# 4-29
+
+Alright let's think about frontend:
+
+- Login Page:
+     - Page 1: login
+        - if logged in, show main
+    
+     - Main Page
+        - SideBar
+        - MainPanel
+            - MainPanelOptions
+
+            - TodoPanel
+            - EditPanel
+            - CanvasPanel
+
+
+What I want to do:
+- build the threads part
+- build the login and user context part
+- build the database backend interactions
+- build the canvas part
+
+
+How do I want to handle components?
+
+Brainstorm:
+- I could construct a component tree
+    - each component could have a render call? Or just be called in its constructor, so when you instantiate
+    it, it shows up
+- I want to have statically defined models so that I don't have to reconstitute things (since that's a pain)
+
+
+
+Alright yeah, components can also have a commit-esque method (although maybe that's case by case) where I
+commit their data
+
+In that sense, I don't even really need to predefine my HTML - I can just generate it on the fly and have my core
+div structure be defined
+
+
+So what would that look like?
+
+<LoginForm>
+<Main>
+  <div> flex-col
+  <TopPanel>
+    
+  <div> flex-row
+      <SideBar>
+      <TodoPanel>
+      <EditPanel>
+      <CanvasPanel>        
+
+  <footer>
+
+
+
+I can just have so many classes:
+components/
+  loginForm.js
+  sidebar.js
+  todopanel.js
+  editpanel.js
+  canvaspanel.js
+
+lib/
+  component.js
+  database.js
+  utils.js
+
+
+Alright let's start to sketch these out:
+
+We have our base:
+
+
+    class Component extends HTMLComponent{
+
+        db attribute
+        state attribute
+
+        constructor (
+            super()
+            const shadow = this.attachShadow({mode: 'open'})
+            customElements.define(this.constructor.name, this.constructor)
+        )
+    }
+
+
+    class LoginForm extends Component {
+        constructor(
+            super()
+
+
+
+
+        )
+    }
+
+
+
+
+
+
+
+
+
+
+
+# 4-27
+
+
+Alright sick progress, I'm in the process of populating the database. Now I need to:
+- write the startup() method that pulls lists from the database and populates them in the sidebar
+    ---> I'll put the populateDb method in there for now
+
+- write the callback so that when I click on a list, it pulls its id from the database 
+- write the rendering functions so that the todo-list-panel renders the todos for the selected list
+
+
+# 4-26
+
+What do I want to add?
+
+Pages:
+- login page
+- Main Page
+
+
+# Features that I want to add
+
+- Pop Up Card Editing
+- Comments
+- Text CLI
+- Dockerize
+-  

{taskai_cli-0.1.3 → taskai_cli-0.1.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: taskai-cli
-Version: 0.1.3
+Version: 0.1.4
 Author-email: Alex Paskal <alexcpaskal@gmail.com>
 Requires-Python: >=3.12
 Requires-Dist: google-genai>=2.8

{taskai_cli-0.1.3 → taskai_cli-0.1.4}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "taskai-cli"
-version = "0.1.3"
+version = "0.1.4"
 description = ""
 authors = [{name = "Alex Paskal", email = "alexcpaskal@gmail.com"}]
 readme = "README.md"

{taskai_cli-0.1.3 → taskai_cli-0.1.4}/taskai/cli.py

@@ -3,6 +3,9 @@ import argparse
 import os
 from datetime import datetime
 import builtins
+import fnmatch
+import sys
+import subprocess
 
 # local
 from taskai.json_dir_database import JsonDirectoryDatabase
@@ -10,11 +13,15 @@ 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.services.repair_database import repair_database_service
 from taskai.help_menu import help_menu
 from taskai.config import GlobalConfig
 
 # external
-from rich import print
+from rich import print, print_json
+from rich.console import Console
+import rich
+from rich.prompt import Prompt
 
 # config
 DB_PATH = ".taskai/task_db"
@@ -24,6 +31,7 @@ db = JsonDirectoryDatabase(
         USER
 )
 db.connect()
+GlobalConfig.load_dict(db.config)
 
 og_help = builtins.help
 def new_help(*args, **kwargs):
@@ -34,16 +42,20 @@ 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
-        
+    def _find_model_by_stringmatch(attr: str, pattern: str) -> TodoItem|TodoList|Comment|None:
+
+        for record_type in [
+            TodoList,
+            TodoItem,
+            Comment
+        ]:
+            batch_attrs = db.read_batch_attr(record_type, attr)
+            inside_out = {v: k for k, v in batch_attrs.items()}  # TODO this is hacky
+            results = fnmatch.filter(batch_attrs.values(), pattern)
+            if results:
+                id_ = inside_out[results[0]]  # might be duplication
+                return db.read(id_)
+                
         return None
 
 
@@ -52,25 +64,28 @@ class Controller:
         print("kwargs:", kwargs)
 
     # CRUD
-    def show_all(show_done=False):
+    def show_all(show_done=True):
         view_lists(db, db.lists, show_done=show_done)
     
-    def show_by_id(id_, show_done=False):
+    def show_by_id(id_, show_done=True):
         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)
+    def show_by_list_name(value: str, show_done=True):
+        model = Controller._find_model_by_stringmatch("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}'")
+            print(f"Could not find list matching pattern '{value}'")
 
-    def show_list(list_id: int|str, show_done=False):
+    def show_list(list_id: int|str, show_done=True):
         view_lists(db, [list_id], show_done=show_done)
     
+    def show_lists():
+        view_lists(db, db.lists.keys(), show_items=False)
+    
     def show_item(item_id: int|str):
         view_item(db, item_id)
 
@@ -92,7 +107,7 @@ class Controller:
         try:
             int(list_id)
         except ValueError:
-            list_ = Controller._find_model_by_substring("name", list_id)
+            list_ = Controller._find_model_by_stringmatch("name", list_id)
             # TODO this should be just lists, not models
             list_id = list_.id
 
@@ -104,7 +119,7 @@ class Controller:
             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 "due_by": item.due_by = datetime.strptime(v, "%m-%d-%Y")
                 case "parent": item.parent = str(v)
                 case "priority": item.priority = int(v)
                 case "depends_on": item.dependency_ids.extend(v.split(","))
@@ -130,7 +145,7 @@ class Controller:
                 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 "due_by": item.due_by = datetime.strptime(v, "%m-%d-%Y")
                 case "parent": item.parent = str(v)
                 case "priority": item.priority = int(v)
                 # TODO handle recurrence
@@ -143,6 +158,15 @@ class Controller:
         db.commit()
         print(f"Deleted {id_}")
     
+    def delete_list_by_name(name: str):
+        list_ = Controller._find_model_by_stringmatch("name", name)
+        if list_:
+            db.delete(list_.id)
+            db.commit()
+        else:
+            Controller.throw_error("Cannot find list by name")
+
+    
     def delete_completed():
         for item_id in db.items.copy():
             item: TodoItem = db.read(item_id)
@@ -166,7 +190,7 @@ class Controller:
         print(db.get_config_value(key))
     
     def list_config():
-        for k, v in db.get_config().items():
+        for k, v in db.get_config().model_dump().items():
             print(f"{k}={v}")
     
     def set_config_value(key: str, value: any):
@@ -181,6 +205,35 @@ class Controller:
     def run_setup_service():
         user_setup_service(db)
 
+    def repair_service():
+        repair_database_service(db)
+
+    def move_item(item_id: int|str, list_identifier: int|str):
+
+        if item_id not in db.items:
+            Controller.throw_error(f"Couldn't find items with id {item_id}")
+        item: TodoItem = db.read(item_id)
+        
+        if _is_int(list_identifier):
+            new_list_: TodoList = db.read(list_identifier)
+        else:
+            new_list_: TodoList = Controller._find_model_by_stringmatch("name", list_identifier)
+        if not new_list_:
+            Controller.throw_error(f"Couldn't locate list by identifier {list_identifier}")
+        
+        # update item
+        item.list_id = new_list_.id
+        db.update(item)
+        
+        db.commit()
+    
+    def add_dependency(src_id: int|str, dst_id: int|str):
+        """Adds a depedency src -> dst, meaning src depends on dst"""
+        src: TodoItem = db.read(src_id)
+        src.dependency_ids.append(dst_id)
+        db.update(src)
+        db.commit()
+
 # utilities
 def _parse_remaining(remaining_args: list[str]) -> tuple[list, dict]:
 
@@ -211,40 +264,33 @@ def _is_int(val: any) -> bool:
     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)
-
+def _clear_screen():
+    if sys.platform == "linux":
+        os.system("clear")
+    elif sys.platform == "windows":
+        os.system("cls")
+    else:
+        os.system("clear")
+
+def execute_commands(*args, **kwargs) -> int:
+    """
+    Return codes:
+        0 -> termination
+        1 -> continue
+    """
     try:
         match args[0]:
+            case "help":
+                print(help_menu['general'])
+
             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 "list": Controller.show_list(*args[2:], **kwargs)
+                    case "lists": Controller.show_lists() 
                     case "item": Controller.show_item(*args[2:], **kwargs)
                     case "items": Controller.show_item(*args[2:], **kwargs)
                     case "examples": Controller.show_examples()
@@ -269,7 +315,7 @@ def entry_point():
                     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 _: Controller.delete_list_by_name(args[1])
 
             case "comment":
                 match args[1]:
@@ -302,10 +348,81 @@ def entry_point():
             case "examples":
                 Controller.show_examples()
 
+            case "repair":
+                Controller.repair_service()
+
+            case "clear":
+                Controller.delete_completed()
+
+            case "move":
+                match args[1]:
+                    case _ if _is_int(args[1]): Controller.move_item(args[1], args[2])
+                    case _: Controller.throw_error("Unrecognized arguments", *args, **kwargs)
+            
+            case "depend":
+                src_id, dst_id = args[1:3]
+                match (src_id, dst_id):
+                    case _ if _is_int(src_id) and _is_int(dst_id): Controller.add_dependency(src_id, dst_id) 
+                    case _: Controller.throw_error("Invalid arrow argument, must be one of (->, <-)")
+            
+            # developer use
+            case "db":
+                import orjson as json
+                print_json(json.dumps(db.read(args[1]).model_dump()).decode())
+
+            case "exit" | "exit()" | "quit":
+                return 0
+
             case _: Controller.throw_error("unrecognized command", *args, **kwargs)
+
+
     except Exception as e: 
         Controller.throw_error(f"encountered exception '{e}'", *args, **kwargs)
 
+    return 1
+
+
+def interactive_program():
+    # console = Console()
+    # builtins.print = console.print
+
+    response = ""
+    _clear_screen()
+    while True:
+
+        try:
+            response = Prompt.ask("Type your commands:", default=response)
+            _clear_screen()
+            args, kwargs = _parse_remaining(response.split(" "))
+            if args[0] == "task":
+                args = args[1:]
+            return_code = execute_commands(*args, **kwargs)
+            if return_code == 0:
+                break
+            Console().rule()
+            
+        except KeyboardInterrupt:
+           break
+        
+    _clear_screen()
+    sys.exit(1)
+
+
+def entry_point():
+    arg_parser = argparse.ArgumentParser()
+    _, argv = arg_parser.parse_known_args()
+
+
+    if not argv:
+        interactive_program()
+
+    if argv[0] in ("help","--help"):
+        print(help_menu["general"])
+        return
+
+    args, kwargs = _parse_remaining(argv)
+
+    execute_commands(*args, **kwargs)
 
 
 if __name__ == "__main__":

{taskai_cli-0.1.3 → taskai_cli-0.1.4}/taskai/json_dir_database.py

@@ -120,6 +120,21 @@ class JsonDirectoryDatabase:
             return Comment(**self.comments[id_])
         else:
             raise RuntimeError("Can't find record to read")
+    
+    def read_batch_attr(self, record_type: type[Base], attr: str, keep_nulls=False) -> dict[id, str]:
+        """Returns a dictonary of attr values for a given attribute name"""
+        record_store = {
+            TodoItem: self.items,
+            TodoList: self.lists,
+            Comment: self.comments
+        }[record_type]
+
+        # TODO make sure attr is on the model type else throw error
+        
+        records = {
+            id_: record[attr] for id_, record in record_store.items() if record.get(attr) or keep_nulls
+        }
+        return records
 
     def update(self, record: Base) -> None:
             
@@ -128,17 +143,28 @@ class JsonDirectoryDatabase:
             assert record.id in self.items, "item doesn't exist"
             
             # update dependencies
-            old_item: TodoItem = self.items[record.id]
+            old_item = 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)
+                old_list = self.lists[old_item["list_id"]]
+                old_list["item_ids"].remove(record.id)
+                new_list = self.lists[record.list_id]
+                new_list["item_ids"].append(record.id)
 
             self.items[record.id] = record.model_dump()
         
+        elif isinstance(record, TodoList):
+            assert record.id in self.lists, "list doesn't exist"
+            old_list: dict = self.lists[record.id]
+            for item_id in old_list["item_ids"]:
+
+                # Remove any items that have been dropped from the list that still hold it as their list id,
+                # as they are now orphans
+                if self.items[item_id]["list_id"] == old_list["id"] and item_id not in record.item_ids:
+                    self.items.pop(item_id)
+            self.lists[record.id] = record.model_dump()
+
         else:
-            raise RuntimeError("don't know what you're creating")
+            raise RuntimeError("don't know what you're updating")
         
     def delete(self, id_: int|str) -> None:
         id_ = str(id_)
@@ -169,8 +195,10 @@ class JsonDirectoryDatabase:
     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 get_config(self) -> CLIConfig:
+        return CLIConfig(**self.user_data.get("config", {}))
 
     def set_config_value(self, key: str, value: any):
+        if key not in CLIConfig.model_fields:
+            raise RuntimeError("Invalid Config Option")
         self.user_data["config"][key] = value

{taskai_cli-0.1.3 → taskai_cli-0.1.4}/taskai/models.py

@@ -53,5 +53,11 @@ class Comment(Base):
     user_id: Optional[str] = None
     created_on: datetime = Field(default_factory=datetime.now)
 
+class CLIConfig(Base):
+
+    # GEMINI
+    GEMINI_MODEL: str = None
+    GEMINI_API_KEY: str = None
+
 class LLMConfig(Base):
     pass

taskai_cli-0.1.4/taskai/services/repair_database.py

@@ -0,0 +1,39 @@
+# local
+from taskai.json_dir_database import JsonDirectoryDatabase
+from taskai.models import TodoItem, TodoList
+
+# external
+from rich import print
+
+def repair_database_service(
+        db: JsonDirectoryDatabase
+):
+    
+    """
+    Repairs the json database
+    """
+    print(("Pruning null item references in lists ..."))
+    for list_id in db.lists:
+        list_: TodoList = db.read(list_id)
+
+        new_list_item_ids = []
+        for item_id in list_.item_ids:
+            if item_id not in db.items:
+                print(f"Pruned reference to null item id {item_id}")
+            else:
+                new_list_item_ids.append(item_id)
+        list_.item_ids = new_list_item_ids
+        db.update(list_)
+    
+    print("Pruning orphan items")
+    bad_item_ids = set()
+    for item_id in db.items:
+        item: TodoItem = db.read(item_id)
+        if item.list_id not in db.lists:
+            print(f"Pruning orphan item {item_id}")
+            db.delete(bad_item_ids)
+            
+
+    db.commit()
+    print("Repair complete!")
+

{taskai_cli-0.1.3 → taskai_cli-0.1.4}/taskai/views.py

@@ -8,7 +8,7 @@ from rich.console import Console
 import rich
 
 
-def view_lists(db: JsonDirectoryDatabase, ids: list[str], show_done=False):
+def view_lists(db: JsonDirectoryDatabase, ids: list[str], show_done=False, show_items=True):
     """Shows all the lists"""
 
     
@@ -25,18 +25,19 @@ def view_lists(db: JsonDirectoryDatabase, ids: list[str], show_done=False):
                 raise RuntimeError("cannot match list")
 
         print(list.id, list.name)
-        for item_id in list.item_ids:
+        if show_items:
+            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]")
+                # 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):