jott-cli 0.4.0__tar.gz → 0.5.1__tar.gz

{jott_cli-0.4.0 → jott_cli-0.5.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: jott-cli
-Version: 0.4.0
+Version: 0.5.1
 Summary: Feature-rich interactive CLI task manager with AI integration, calendar sync, and keyword automation
 Author-email: Scott Anderson <sonander@gmail.com>
 Maintainer-email: Scott Anderson <sonander@gmail.com>
@@ -9,6 +9,7 @@ Project-URL: Homepage, https://github.com/son1112/jot
 Project-URL: Repository, https://github.com/son1112/jot
 Project-URL: Issues, https://github.com/son1112/jot/issues
 Project-URL: Changelog, https://github.com/son1112/jot/blob/main/CHANGELOG.md
+Project-URL: Documentation, https://son1112.github.io/jot/
 Keywords: cli,task-management,productivity,todo,gtd,ai-integration
 Classifier: Development Status :: 4 - Beta
 Classifier: Environment :: Console
@@ -29,6 +30,7 @@ Requires-Dist: google-auth-oauthlib>=0.5.0
 Requires-Dist: google-auth-httplib2>=0.1.0
 Requires-Dist: google-api-python-client>=2.0.0
 Requires-Dist: filelock>=3.0.0
+Requires-Dist: prompt-toolkit>=3.0
 Provides-Extra: dev
 Requires-Dist: pytest>=7.0; extra == "dev"
 Requires-Dist: pytest-cov>=4.0; extra == "dev"
@@ -40,6 +42,10 @@ Provides-Extra: mcp
 Requires-Dist: mcp>=1.0.0; extra == "mcp"
 Provides-Extra: tts
 Requires-Dist: pyttsx3>=2.90; extra == "tts"
+Provides-Extra: docs
+Requires-Dist: sphinx<8.0,>=5.0; extra == "docs"
+Requires-Dist: furo>=2023.1; extra == "docs"
+Requires-Dist: sphinx-autodoc-typehints>=1.20; extra == "docs"
 Dynamic: license-file
 
 # jott - AI-Powered CLI Project Management

jott_cli-0.5.1/jot/__init__.py

@@ -0,0 +1,53 @@
+"""jott package - Simple, extensible interactive CLI task list
+
+This package provides modular components for the jott task management system.
+"""
+
+import importlib.util
+import os
+from pathlib import Path
+
+__version__ = "0.5.1"
+
+# When building Sphinx docs, skip the dynamic import bridge and heavy deps.
+# Set JOT_SPHINX_BUILD=1 in docs/sphinx/conf.py before importing jot.
+if os.environ.get('JOT_SPHINX_BUILD'):
+    main = None
+else:
+    # Import extracted classes from their new modules
+    from jot.core.id_manager import IDManager
+    from jot.core.task_manager import TaskManager
+    from jot.projects.registry import ProjectRegistry
+    from jot.projects.backup import ProjectBackup
+    from jot.categories.manager import CategoryManager
+    from jot.categories.config import CategoryConfig
+    from jot.categories.templates import CategoryTemplates
+    from jot.integrations.gcal.account_manager import GoogleCalendarAccountManager
+    from jot.integrations.gcal.auth import GoogleCalendarAuth
+    from jot.integrations.gcal.events import create_gcal_event, fetch_gcal_events
+    from jot.integrations.keywords.handler import KeywordHandler
+
+    # Load jot.py for main() and other not-yet-extracted components
+    _jot_script_path = Path(__file__).parent.parent / 'jot.py'
+    _spec = importlib.util.spec_from_file_location("_jot_script", _jot_script_path)
+    _jot_script = importlib.util.module_from_spec(_spec)
+    _spec.loader.exec_module(_jot_script)
+
+    # Export main function from jot.py
+    main = _jot_script.main
+
+__all__ = [
+    'main',
+    'TaskManager',
+    'ProjectRegistry',
+    'ProjectBackup',
+    'IDManager',
+    'CategoryManager',
+    'CategoryConfig',
+    'CategoryTemplates',
+    'KeywordHandler',
+    'GoogleCalendarAccountManager',
+    'GoogleCalendarAuth',
+    'create_gcal_event',
+    'fetch_gcal_events',
+]

jott_cli-0.5.1/jot/_app_navigation_mixin.py

@@ -0,0 +1,148 @@
+"""Navigation mixin — navigation, toggle, and switching helpers for App."""
+
+import time
+from pathlib import Path
+
+from jot.categories.manager import CategoryManager
+from jot.commands import CommandHandler
+from jot.core.constants import MODE_QUICK_ADD
+from jot.core.task_manager import TaskManager
+from jot.ui.styles import RESET, CYAN
+from jot.utils.date_utils import get_today_day_name
+
+
+class AppNavigationMixin:
+    """Navigation, toggle, and category/project switching for App."""
+
+    def _handle_navigation(self, key, tasks_to_display):
+        """Process UP/DOWN/SHIFT_UP/SHIFT_DOWN.  Returns True if
+        the key was a navigation key."""
+        filtered = (
+            tasks_to_display if self.state.show_today_only else None)
+
+        if key == 'UP':
+            self.task_manager.set_prev_current(filtered)
+            return True
+        if key == 'DOWN':
+            self.task_manager.set_next_current(filtered)
+            return True
+        if key == 'SHIFT_UP':
+            self.task_manager.move_task_up()
+            return True
+        if key == 'SHIFT_DOWN':
+            self.task_manager.move_task_down()
+            return True
+        return False
+
+    def _handle_toggle(self, key):
+        """Process shared toggle keys A/O/Y/F/?.  Returns True if
+        the key was a toggle key."""
+        st = self.state
+
+        toggle_map = {
+            'A': ('show_archived', 'archived tasks'),
+            'O': ('sort_by_day', None),
+            'Y': ('show_today_only', None),
+            'F': ('show_notes_inline', 'inline notes'),
+            '?': ('show_shortcuts', 'shortcuts'),
+        }
+
+        if key not in toggle_map:
+            return False
+
+        attr, label = toggle_map[key]
+
+        if key == 'O':
+            st.sort_by_day = not st.sort_by_day
+            msg = "Sorting by day" if st.sort_by_day else "Normal order"
+        elif key == 'Y':
+            st.show_today_only = not st.show_today_only
+            today = get_today_day_name()
+            msg = (f"Showing only {today} tasks"
+                   if st.show_today_only else "Showing all tasks")
+        else:
+            current = getattr(st, attr)
+            setattr(st, attr, not current)
+            new_val = not current
+            status = "Showing" if new_val else "Hiding"
+            msg = f"{status} {label}"
+
+        print(f"\n{CYAN}\u2713 {msg}{RESET}")
+        time.sleep(0.3)
+        st.input_buffer = ""
+        return True
+
+    def _reload_task_manager(self, task_manager):
+        """Replace the active TaskManager and CommandHandler."""
+        import os
+        self.task_manager = task_manager
+        self.command_handler = CommandHandler(
+            task_manager, registry=self.registry)
+        self._last_mtime = (
+            os.path.getmtime(task_manager.storage_file)
+            if task_manager.storage_file.exists() else 0)
+
+    def _handle_switch_category(self):
+        """Shift+C — switch category via picker."""
+        result = self.command_handler.switch_category()
+        if isinstance(result, tuple) and result[0] == 'switch_category':
+            _, new_category, new_is_global = result
+            if new_is_global:
+                tm = TaskManager(
+                    category=new_category, is_global=True,
+                    project_registry=self.registry)
+            else:
+                tm = TaskManager(
+                    directory=self.target_dir, category=new_category,
+                    is_global=False, project_registry=self.registry)
+            self._reload_task_manager(tm)
+            print(f"\u2713 Switched to category: "
+                  f"{new_category or 'default'}")
+            print("\nPress Enter to continue...", end='', flush=True)
+            input()
+        self.state.input_buffer = ""
+
+    def _handle_switch_project(self):
+        """Shift+Z — switch project via picker."""
+        result = self.command_handler.switch_project()
+        if isinstance(result, tuple) and result[0] == 'switch_project':
+            _, proj_name, project_path = result
+            self.target_dir = project_path
+            self.project_name = proj_name
+            tm = TaskManager(
+                directory=self.target_dir, category=None,
+                is_global=False, project_registry=self.registry)
+            self._reload_task_manager(tm)
+            print(f"\u2713 Switched to project: {proj_name}")
+            print("\nPress Enter to continue...", end='', flush=True)
+            input()
+        self.state.input_buffer = ""
+
+    def _handle_tab_cycle(self):
+        """Tab — cycle through categories in the project."""
+        cat_manager = CategoryManager(project_dir=self.target_dir)
+        categories = cat_manager.discover_categories()
+        if not categories:
+            self.state.input_buffer = ""
+            return
+
+        current_cat = self.task_manager.category
+        if current_cat is None:
+            next_cat = categories[0]
+        else:
+            try:
+                idx = categories.index(current_cat)
+                next_cat = (
+                    categories[idx + 1]
+                    if idx + 1 < len(categories) else None)
+            except ValueError:
+                next_cat = categories[0]
+
+        tm = TaskManager(
+            directory=self.target_dir, category=next_cat,
+            is_global=False, project_registry=self.registry)
+        self._reload_task_manager(tm)
+        label = next_cat if next_cat else "default"
+        print(f"\n{CYAN}\u2192 {label}{RESET}")
+        time.sleep(0.2)
+        self.state.input_buffer = ""

jott_cli-0.5.1/jot/_dispatch_mixin.py

@@ -0,0 +1,302 @@
+"""Dispatch mixin — mode-specific key dispatch for App."""
+
+import time
+
+from jot.core.constants import (
+    MODE_QUICK_ADD, MODE_COMMAND, MODE_MULTISELECT,
+    MODE_FUZZY_SEARCH, MODE_ALL_CATEGORIES,
+)
+from jot.ui.styles import RESET, CYAN
+
+
+class DispatchMixin:
+    """Mode-specific key dispatch methods for App."""
+
+    def _dispatch_quick_add(self, key, tasks_to_display):
+        """Handle a keypress in QUICK_ADD mode."""
+        st = self.state
+
+        if key == '\r' or key == '\n':
+            self._quick_add_enter()
+            return
+
+        if key == '\x1b':
+            st.mode = MODE_COMMAND
+            st.input_buffer = ""
+            return
+
+        if key == '\x7f':
+            st.input_buffer = st.input_buffer[:-1]
+            return
+
+        if key == 'C':
+            self._handle_switch_category()
+            return
+
+        if key == 'Z':
+            self._handle_switch_project()
+            return
+
+        if key == 'L':
+            should_toggle, new_mode = (
+                self.command_handler.toggle_all_categories_view(st.mode))
+            if should_toggle:
+                st.mode = new_mode
+            st.input_buffer = ""
+            return
+
+        if key == '=':
+            self.task_manager.sort_by_priority()
+            st.input_buffer = ""
+            return
+
+        method_name = self._QUICK_ADD_SIMPLE.get(key)
+        if method_name:
+            getattr(self.command_handler, method_name)()
+            st.input_buffer = ""
+            return
+
+        if self._handle_toggle(key):
+            return
+
+        if key == 'V':
+            st.mode = MODE_MULTISELECT
+            st.selected_tasks.clear()
+            st.input_buffer = ""
+            return
+
+        if key == '\x06':  # Ctrl+F
+            st.mode = MODE_FUZZY_SEARCH
+            st.search_buffer = ""
+            st.filtered_tasks = []
+            st.input_buffer = ""
+            return
+
+        if key == '\t':
+            self._handle_tab_cycle()
+            return
+
+        if self._handle_navigation(key, tasks_to_display):
+            return
+
+        if len(key) == 1 and key.isprintable():
+            st.input_buffer += key
+
+    def _quick_add_enter(self):
+        """Handle Enter key in quick-add mode."""
+        st = self.state
+        if st.input_buffer.strip():
+            result = self.task_manager.add_task(st.input_buffer.strip())
+            if isinstance(result, dict):
+                if result.get('action') == 'broadcast':
+                    self._confirm_broadcast(result)
+                elif result.get('action') == 'route':
+                    self._execute_route(result)
+            st.input_buffer = ""
+        else:
+            tally_count = self.task_manager.increment_tally()
+            if tally_count:
+                print(f"\n{CYAN}\u2713 Tally: \u00d7{tally_count}{RESET}")
+                time.sleep(0.3)
+
+    def _confirm_broadcast(self, info):
+        """Prompt user before broadcasting task to all projects."""
+        from jot.ui.input import restore_terminal
+        projects = (self.task_manager.keyword_handler
+                    .project_registry.list_projects())
+        n = len(projects)
+        print(f"\n\u26a0  Broadcast \"{info['task_text']}\" "
+              f"to {n} projects? (y/N): ", end='', flush=True)
+        restore_terminal()
+        if input().strip().lower() == 'y':
+            count = self.task_manager._route_to_project(
+                info['task_text'], info['project_name'],
+                info['priority'], info['status'],
+                info['labels'], info['effort'])
+            print(f"{CYAN}\u2713 Added to {count} projects{RESET}")
+        else:
+            print("Cancelled")
+        time.sleep(0.5)
+
+    def _execute_route(self, info):
+        """Route task to a single project with feedback."""
+        count = self.task_manager._route_to_project(
+            info['task_text'], info['project_name'],
+            info['priority'], info['status'],
+            info['labels'], info['effort'])
+        if count:
+            print(f"\n{CYAN}\u2713 Routed to "
+                  f"{info['project_name']}{RESET}")
+            time.sleep(0.5)
+
+    def _dispatch_command(self, key, tasks_to_display):
+        """Handle a keypress in COMMAND mode."""
+        st = self.state
+
+        if key == 'a':
+            st.mode = MODE_QUICK_ADD
+            st.input_buffer = ""
+            return
+
+        if self._handle_navigation(key, tasks_to_display):
+            return
+
+        if key == '\r' or key == '\n':
+            tally_count = self.task_manager.increment_tally()
+            if tally_count:
+                print(f"\n{CYAN}\u2713 Tally: \u00d7{tally_count}{RESET}")
+                time.sleep(0.3)
+            return
+
+        if key in ('A', 'O', 'Y'):
+            self._handle_toggle(key)
+            return
+
+        if key:
+            st.running = self.command_handler.handle(key)
+
+    def _dispatch_multiselect(self, key, tasks_to_display):
+        """Handle a keypress in MULTISELECT mode."""
+        st = self.state
+
+        if key == '\x1b':
+            st.mode = MODE_QUICK_ADD
+            st.selected_tasks.clear()
+            return
+
+        if key == ' ':
+            current_task = self.task_manager.get_current_task()
+            if current_task:
+                task_id = current_task['id']
+                if task_id in st.selected_tasks:
+                    st.selected_tasks.remove(task_id)
+                else:
+                    st.selected_tasks.add(task_id)
+            return
+
+        if key == 'A':
+            for task in self.task_manager.tasks:
+                st.selected_tasks.add(task['id'])
+            return
+
+        if key == 'N':
+            st.selected_tasks.clear()
+            return
+
+        filtered = (
+            tasks_to_display if st.show_today_only else None)
+
+        if key == 'UP':
+            self.task_manager.set_prev_current(filtered)
+            return
+        if key == 'DOWN':
+            self.task_manager.set_next_current(filtered)
+            return
+
+        if key == 'SHIFT_UP':
+            self.task_manager.set_prev_current(filtered)
+            current_task = self.task_manager.get_current_task()
+            if current_task:
+                st.selected_tasks.add(current_task['id'])
+            return
+        if key == 'SHIFT_DOWN':
+            self.task_manager.set_next_current(filtered)
+            current_task = self.task_manager.get_current_task()
+            if current_task:
+                st.selected_tasks.add(current_task['id'])
+            return
+
+        if key == 'B':
+            self._multiselect_bulk_action()
+            return
+
+    def _multiselect_bulk_action(self):
+        """Process bulk action menu in multiselect mode."""
+        st = self.state
+        if not st.selected_tasks:
+            return
+
+        action = self.command_handler.bulk_actions_menu(st.selected_tasks)
+        action_map = {
+            'priority': self.command_handler.bulk_set_priority,
+            'status': self.command_handler.bulk_set_status,
+            'delete': self.command_handler.bulk_delete,
+            'archive': self.command_handler.bulk_archive,
+        }
+        handler = action_map.get(action)
+        if handler:
+            handler(st.selected_tasks)
+            st.selected_tasks.clear()
+
+    def _dispatch_fuzzy_search(self, key):
+        """Handle a keypress in FUZZY_SEARCH mode."""
+        st = self.state
+
+        if key == '\x1b':
+            st.mode = MODE_QUICK_ADD
+            st.search_buffer = ""
+            st.match_positions = {}
+            return
+
+        if key == '\r' or key == '\n':
+            current_task = self.task_manager.get_current_task()
+            if current_task:
+                st.mode = MODE_QUICK_ADD
+                st.search_buffer = ""
+                st.match_positions = {}
+            return
+
+        if key == '\x7f':
+            if st.search_buffer:
+                st.search_buffer = st.search_buffer[:-1]
+            return
+
+        if key == '\x01':  # Ctrl+A
+            st.include_archived_in_search = (
+                not st.include_archived_in_search)
+            return
+
+        if key in ('UP', 'DOWN'):
+            self._fuzzy_navigate(key)
+            return
+
+        if len(key) == 1 and key.isprintable():
+            st.search_buffer += key
+
+    def _fuzzy_navigate(self, key):
+        """Navigate within fuzzy search filtered results."""
+        st = self.state
+        if not st.filtered_tasks:
+            return
+
+        current_task = self.task_manager.get_current_task()
+        if not current_task:
+            return
+
+        current_id = current_task['id']
+        filtered_ids = [t[0]['id'] for t in st.filtered_tasks]
+        if current_id not in filtered_ids:
+            return
+
+        idx = filtered_ids.index(current_id)
+        if key == 'UP' and idx > 0:
+            self.task_manager.set_current(
+                st.filtered_tasks[idx - 1][0]['id'])
+        elif key == 'DOWN' and idx < len(st.filtered_tasks) - 1:
+            self.task_manager.set_current(
+                st.filtered_tasks[idx + 1][0]['id'])
+
+    def _dispatch_all_categories(self, key, tasks_to_display):
+        """Handle a keypress in ALL_CATEGORIES mode."""
+        st = self.state
+
+        if key == '\x1b' or key == 'L':
+            st.mode = MODE_QUICK_ADD
+            return
+
+        filtered = (
+            tasks_to_display if st.show_today_only else None)
+        if key == 'UP':
+            self.task_manager.set_prev_current(filtered)
+        elif key == 'DOWN':
+            self.task_manager.set_next_current(filtered)