jott-cli 0.2.2__tar.gz → 0.3.0__tar.gz

{jott_cli-0.2.2/jott_cli.egg-info → jott_cli-0.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: jott-cli
-Version: 0.2.2
+Version: 0.3.0
 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>

jott_cli-0.3.0/jot/__init__.py

@@ -0,0 +1,47 @@
+"""jot package - Simple, extensible interactive CLI task list
+
+This package provides modular components for the jot task management system.
+"""
+
+import importlib.util
+from pathlib import Path
+
+# 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
+
+__version__ = "0.3.0"
+
+__all__ = [
+    'main',
+    'TaskManager',
+    'ProjectRegistry',
+    'ProjectBackup',
+    'IDManager',
+    'CategoryManager',
+    'CategoryConfig',
+    'CategoryTemplates',
+    'KeywordHandler',
+    'GoogleCalendarAccountManager',
+    'GoogleCalendarAuth',
+    'create_gcal_event',
+    'fetch_gcal_events',
+]

jott_cli-0.3.0/jot/categories/config.py

@@ -0,0 +1,133 @@
+"""Category configuration and color management"""
+
+import json
+from pathlib import Path
+
+
+class CategoryConfig:
+    """Manages category colors and configuration"""
+
+    # ANSI color codes
+    COLORS = {
+        'red': '\033[91m',
+        'green': '\033[92m',
+        'yellow': '\033[93m',
+        'blue': '\033[94m',
+        'magenta': '\033[95m',
+        'cyan': '\033[96m',
+        'white': '\033[97m',
+        'orange': '\033[38;5;208m',
+        'purple': '\033[38;5;141m',
+        'pink': '\033[38;5;213m',
+        'teal': '\033[38;5;44m',
+        'lime': '\033[38;5;154m',
+    }
+
+    # Default color assignments for common categories
+    DEFAULT_COLORS = {
+        'default': 'white',
+        'features': 'green',
+        'bugs': 'red',
+        'testing': 'yellow',
+        'docs': 'blue',
+        'backlog': 'cyan',
+        'ideas': 'purple',
+        'work': 'teal',
+        'personal': 'pink',
+        'bills': 'orange',
+        'health': 'lime',
+    }
+
+    def __init__(self, project_dir=None):
+        """Initialize category config"""
+        self.project_dir = Path(project_dir) if project_dir else Path.cwd()
+        self.config_file = self.project_dir / '.jot.config.json'
+        self.config = self._load_config()
+
+    def _load_config(self):
+        """Load config from .jot.config.json"""
+        if self.config_file.exists():
+            try:
+                with open(self.config_file, 'r') as f:
+                    return json.load(f)
+            except json.JSONDecodeError:
+                return {}
+        return {}
+
+    def _save_config(self):
+        """Save config to .jot.config.json"""
+        self.config_file.parent.mkdir(parents=True, exist_ok=True)
+        with open(self.config_file, 'w') as f:
+            json.dump(self.config, indent=2, fp=f)
+
+    def get_color(self, category_name, for_global=False):
+        """Get ANSI color code for a category"""
+        # Check custom colors first
+        if 'colors' in self.config and category_name in self.config['colors']:
+            color_name = self.config['colors'][category_name]
+            return self.COLORS.get(color_name, '\033[96m')  # Default to cyan
+
+        # Use default color for known categories
+        if category_name in self.DEFAULT_COLORS:
+            return self.COLORS[self.DEFAULT_COLORS[category_name]]
+
+        # Global categories get magenta by default
+        if for_global:
+            return self.COLORS['magenta']
+
+        # Unknown local categories get cyan
+        return self.COLORS['cyan']
+
+    def set_color(self, category_name, color_name):
+        """Set color for a category"""
+        if color_name not in self.COLORS:
+            return False, f"Invalid color. Available: {', '.join(sorted(self.COLORS.keys()))}"
+
+        if 'colors' not in self.config:
+            self.config['colors'] = {}
+
+        self.config['colors'][category_name] = color_name
+        self._save_config()
+        return True, f"Set {category_name} color to {color_name}"
+
+    def get_all_colors(self):
+        """Get all configured colors"""
+        return self.config.get('colors', {})
+
+    def reset_colors(self):
+        """Reset all colors to defaults"""
+        if 'colors' in self.config:
+            del self.config['colors']
+            self._save_config()
+        return True
+
+    def list_available_colors(self):
+        """List all available color names"""
+        return sorted(self.COLORS.keys())
+
+    def get_tts_config(self):
+        """Get TTS configuration settings"""
+        default_tts = {
+            'enabled': True,
+            'rate': 150,  # Words per minute
+            'volume': 0.9,  # 0.0 to 1.0
+            'voice': None,  # None = system default
+        }
+        return self.config.get('tts', default_tts)
+
+    def set_tts_config(self, **kwargs):
+        """Set TTS configuration settings"""
+        if 'tts' not in self.config:
+            self.config['tts'] = {
+                'enabled': True,
+                'rate': 150,
+                'volume': 0.9,
+                'voice': None,
+            }
+
+        for key, value in kwargs.items():
+            if key in ['enabled', 'rate', 'volume', 'voice']:
+                self.config['tts'][key] = value
+
+        self._save_config()
+        return True

jott_cli-0.3.0/jot/categories/manager.py

@@ -0,0 +1,146 @@
+"""Category management for jot projects"""
+
+from pathlib import Path
+
+
+class CategoryManager:
+    """Manages categories within a project directory and globally"""
+
+    MAX_CATEGORIES = 12
+    GLOBAL_CATEGORIES_DIR = Path.home() / '.jot-categories'
+
+    def __init__(self, project_dir=None):
+        """Initialize category manager for a project directory"""
+        self.project_dir = Path(project_dir) if project_dir else Path.cwd()
+
+    def discover_categories(self):
+        """
+        Find all category files in .jot-categories/ directory.
+        Returns list of category names (without .json suffix).
+        """
+        categories = []
+
+        # Check if .jot-categories directory exists
+        categories_dir = self.project_dir / '.jot-categories'
+        if not categories_dir.exists():
+            return categories
+
+        # Find all .json files in .jot-categories/
+        for file in categories_dir.glob('*.json'):
+            # Extract category name from filename
+            # features.json -> features
+            category = file.stem  # Get filename without extension
+            categories.append(category)
+
+        return sorted(categories)
+
+    def count_categories(self):
+        """Count existing categories in the project"""
+        return len(self.discover_categories())
+
+    def can_create_category(self, category_name):
+        """
+        Check if a new category can be created.
+        Returns (can_create: bool, message: str)
+        """
+        existing = self.discover_categories()
+
+        # Category already exists
+        if category_name in existing:
+            return True, None
+
+        # Check limit
+        if len(existing) >= self.MAX_CATEGORIES:
+            return (
+                False,
+                f"Category limit reached ({self.MAX_CATEGORIES} max). Existing: {', '.join(existing)}",
+            )
+
+        return True, None
+
+    def get_warning_message(self, category_name):
+        """
+        Get warning message if approaching category limit.
+        Returns None if no warning needed.
+        """
+        existing = self.discover_categories()
+
+        # No warning if category already exists
+        if category_name in existing:
+            return None
+
+        count = len(existing)
+
+        if count == 10:
+            return f"Warning: Approaching category limit ({count + 1}/12 categories)"
+        elif count == 11:
+            return f"Warning: Near category limit ({count + 1}/12 categories)"
+        elif count >= 12:
+            return f"Error: Category limit reached ({self.MAX_CATEGORIES} max)"
+
+        return None
+
+    def discover_global_categories(self):
+        """
+        Find all global category files in ~/.jot-categories/
+        Returns list of category names (without .json suffix).
+        Excludes special files like ids, archive, etc.
+        """
+        # Return empty list if global directory doesn't exist
+        if not self.GLOBAL_CATEGORIES_DIR.exists():
+            return []
+
+        categories = []
+        reserved_names = {'ids', 'archive', 'index', 'config'}
+
+        # Find all *.json files in global categories directory
+        for file in self.GLOBAL_CATEGORIES_DIR.glob('*.json'):
+            category = file.stem  # filename without .json
+
+            # Skip reserved names and special files
+            if category not in reserved_names and not category.endswith('.ids'):
+                categories.append(category)
+
+        return sorted(categories)
+
+    def category_exists_locally(self, category_name):
+        """Check if category exists locally in project"""
+        categories_dir = self.project_dir / '.jot-categories'
+        local_file = categories_dir / f'{category_name}.json'
+        return local_file.exists()
+
+    def category_exists_globally(self, category_name):
+        """Check if category exists globally"""
+        global_file = self.GLOBAL_CATEGORIES_DIR / f'{category_name}.json'
+        return global_file.exists()
+
+    def resolve_category_location(self, category_name):
+        """
+        Determine if category is local, global, or new.
+        Returns: 'local', 'global', or 'new'
+        """
+        if self.category_exists_locally(category_name):
+            return 'local'
+        elif self.category_exists_globally(category_name):
+            return 'global'
+        else:
+            return 'new'
+
+    def get_category_file_path(self, category_name, is_global=False):
+        """
+        Get the full path for a category file.
+
+        Args:
+            category_name: Name of the category
+            is_global: If True, return global path; if False, return local path
+
+        Returns:
+            Path object for the category file
+        """
+        if is_global:
+            return self.GLOBAL_CATEGORIES_DIR / f'{category_name}.json'
+        else:
+            # Local categories are stored in .jot-categories/ directory
+            categories_dir = self.project_dir / '.jot-categories'
+            categories_dir.mkdir(exist_ok=True)
+            return categories_dir / f'{category_name}.json'

jott_cli-0.3.0/jot/categories/templates.py

@@ -0,0 +1,121 @@
+"""Category templates for quick project setup"""
+
+from pathlib import Path
+
+from jot.categories.config import CategoryConfig
+from jot.categories.manager import CategoryManager
+from jot.core.task_manager import TaskManager
+
+
+class CategoryTemplates:
+    """Manages category templates for quick project setup"""
+
+    TEMPLATES = {
+        'software-dev': {
+            'name': 'Software Development',
+            'description': 'Standard software project categories',
+            'categories': ['features', 'bugs', 'testing', 'docs'],
+            'sample_tasks': {
+                'features': ['Plan next sprint', 'Review backlog'],
+                'bugs': ['Triage bug reports'],
+                'testing': ['Run test suite', 'Update test coverage'],
+                'docs': ['Update README', 'Write API docs'],
+            },
+        },
+        'personal': {
+            'name': 'Personal Tasks',
+            'description': 'Personal life management categories',
+            'categories': ['work', 'home', 'bills', 'health'],
+            'sample_tasks': {
+                'work': ['Check email', 'Weekly planning'],
+                'home': ['Grocery shopping', 'Clean house'],
+                'bills': ['Pay rent', 'Review budget'],
+                'health': ['Exercise', 'Doctor appointment'],
+            },
+        },
+        'creative': {
+            'name': 'Creative Project',
+            'description': 'Creative and content creation categories',
+            'categories': ['ideas', 'drafts', 'editing', 'publishing'],
+            'sample_tasks': {
+                'ideas': ['Brainstorm topics', 'Research inspiration'],
+                'drafts': ['Write first draft'],
+                'editing': ['Review and revise'],
+                'publishing': ['Format and publish'],
+            },
+        },
+        'business': {
+            'name': 'Business Management',
+            'description': 'Business and client work categories',
+            'categories': ['leads', 'clients', 'invoicing', 'marketing'],
+            'sample_tasks': {
+                'leads': ['Follow up prospects', 'Update CRM'],
+                'clients': ['Client meetings', 'Project deliverables'],
+                'invoicing': ['Send invoices', 'Track payments'],
+                'marketing': ['Social media posts', 'Email campaign'],
+            },
+        },
+        'academic': {
+            'name': 'Academic/Research',
+            'description': 'Academic and research project categories',
+            'categories': ['reading', 'research', 'writing', 'teaching'],
+            'sample_tasks': {
+                'reading': ['Literature review', 'Paper analysis'],
+                'research': ['Experiment design', 'Data collection'],
+                'writing': ['Draft paper', 'Revise manuscript'],
+                'teaching': ['Prepare lecture', 'Grade assignments'],
+            },
+        },
+    }
+
+    def __init__(self, project_dir=None):
+        """Initialize templates manager"""
+        self.project_dir = Path(project_dir) if project_dir else Path.cwd()
+        self.cat_manager = CategoryManager(project_dir=self.project_dir)
+        self.cat_config = CategoryConfig(project_dir=self.project_dir)
+
+    def list_templates(self):
+        """List all available templates"""
+        return self.TEMPLATES
+
+    def apply_template(self, template_name, with_samples=False):
+        """Apply a template to create categories"""
+        if template_name not in self.TEMPLATES:
+            return False, f"Template '{template_name}' not found"
+
+        template = self.TEMPLATES[template_name]
+        categories_to_create = template['categories']
+
+        existing_categories = self.cat_manager.discover_categories()
+        total_after = len(existing_categories) + len(categories_to_create)
+
+        if total_after > CategoryManager.MAX_CATEGORIES:
+            return (
+                False,
+                f"Cannot create {len(categories_to_create)} categories. "
+                f"Would exceed limit ({CategoryManager.MAX_CATEGORIES} max)",
+            )
+
+        conflicts = [c for c in categories_to_create if c in existing_categories]
+        if conflicts:
+            return False, f"Categories already exist: {', '.join(conflicts)}"
+
+        created = []
+        for category in categories_to_create:
+            tm = TaskManager(
+                directory=self.project_dir,
+                category=category,
+                is_global=False,
+            )
+            if with_samples and category in template.get('sample_tasks', {}):
+                for task_text in template['sample_tasks'][category]:
+                    tm.add_task(task_text)
+            created.append(category)
+
+        return True, f"Created {len(created)} categories: {', '.join(created)}"
+
+    def get_template_info(self, template_name):
+        """Get detailed information about a template"""
+        if template_name not in self.TEMPLATES:
+            return None
+        return self.TEMPLATES[template_name]

jott_cli-0.3.0/jot/commands/__init__.py

@@ -0,0 +1,5 @@
+"""Command handling for jot interactive UI"""
+
+from jot.commands.handler import CommandHandler
+
+__all__ = ['CommandHandler']