jott-cli 0.8.1__tar.gz → 0.8.2__tar.gz

{jott_cli-0.8.1/jott_cli.egg-info → jott_cli-0.8.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: jott-cli
-Version: 0.8.1
+Version: 0.8.2
 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.8.1 → jott_cli-0.8.2}/jot/__init__.py

@@ -3,18 +3,15 @@
 This package provides modular components for the jott task management system.
 """
 
-import importlib.util
 import os
-from pathlib import Path
 
-__version__ = "0.8.1"
+__version__ = "0.8.2"
 
-# When building Sphinx docs, skip the dynamic import bridge and heavy deps.
+# When building Sphinx docs, skip the heavy runtime imports.
 # 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
@@ -27,14 +24,7 @@ else:
     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
+    from jot.main import main
 
 __all__ = [
     'main',

jott_cli-0.8.2/jot/main.py

@@ -0,0 +1,227 @@
+"""jott entry point.
+
+Hosts main() and the CLI argument plumbing previously in the
+repo-root jot.py script. The console-script entry point in
+pyproject.toml resolves through jot.__init__, which re-exports
+main from this module.
+"""
+
+import json
+import sys
+from pathlib import Path
+
+from jot.core.task_manager import TaskManager
+from jot.projects.registry import ProjectRegistry
+from jot.categories.manager import CategoryManager
+from jot.commands import CommandHandler
+from jot.cli import handle_cli_args
+from jot.ui import display_help
+
+
+def load_auto_backlog_config():
+    """Load auto-backlog configuration from ~/.jot-config.json"""
+    config_file = Path.home() / '.jot-config.json'
+    default_config = {
+        'enabled': True,
+        'age_threshold_days': 30,
+        'backlog_category': 'backlog',
+    }
+
+    if not config_file.exists():
+        return default_config
+
+    try:
+        with open(config_file, 'r') as f:
+            config = json.load(f)
+            result = default_config.copy()
+            result.update(config.get('auto_backlog', {}))
+            return result
+    except (json.JSONDecodeError, IOError):
+        return default_config
+
+
+def _parse_flags(args):
+    """Extract --all, --global, --category/-c flags from args.
+
+    Returns (args, broadcast_all, explicit_global, category) with
+    consumed flags removed from args.
+    """
+    broadcast_all = '--all' in args
+    if broadcast_all:
+        args.remove('--all')
+
+    explicit_global = '--global' in args
+    if explicit_global:
+        args.remove('--global')
+
+    category = None
+    for flag in ('--category', '-c'):
+        if flag in args:
+            idx = args.index(flag)
+            if idx + 1 < len(args):
+                category = args[idx + 1]
+                args = args[:idx] + args[idx + 2 :]
+            break
+
+    return args, broadcast_all, explicit_global, category
+
+
+def _resolve_global(category, explicit_global, target_dir):
+    """Determine whether a category should be global or local."""
+    if not category:
+        return False
+
+    if explicit_global:
+        return True
+
+    cat_manager = CategoryManager(project_dir=target_dir or Path.cwd())
+    location = cat_manager.resolve_category_location(category)
+
+    if location == 'global':
+        return True
+    if location == 'local':
+        return False
+
+    # New category — create locally by default
+    can_create, error_msg = cat_manager.can_create_category(category)
+    if not can_create:
+        print(f"✗ {error_msg}")
+        sys.exit(1)
+
+    warning_msg = cat_manager.get_warning_message(category)
+    if warning_msg:
+        print(warning_msg)
+
+    return False
+
+
+def _resolve_project_and_task(args, registry):
+    """Parse remaining args into (target_dir, project_name, initial_task)."""
+    target_dir = None
+    project_name = None
+    initial_task = None
+
+    if args:
+        project_path = registry.get_project_path(args[0])
+        if project_path:
+            target_dir = project_path
+            project_name = args[0]
+            if len(args) > 1:
+                initial_task = ' '.join(args[1:])
+        else:
+            initial_task = ' '.join(args)
+
+    return target_dir, project_name, initial_task
+
+
+def _handle_initial_task(
+    task_manager, initial_task, broadcast_all, registry, project_name, is_global, category
+):
+    """Add a task supplied on the command line and exit."""
+    if initial_task and broadcast_all:
+        projects = registry.list_projects()
+        if not projects:
+            print("✗ No registered projects found. Use --register to add projects.")
+            return
+
+        n = len(projects)
+        confirm = input(f"⚠  Broadcast \"{initial_task}\" to {n} projects? (y/N): ").strip().lower()
+        if confirm != 'y':
+            print("Cancelled.")
+            return
+
+        added = 0
+        seen_paths = set()
+        for _, proj_path in projects.items():
+            resolved = str(Path(proj_path).resolve())
+            if resolved in seen_paths:
+                continue
+            seen_paths.add(resolved)
+            tm = TaskManager(directory=proj_path, project_registry=registry)
+            all_texts = [t['text'] for t in tm.tasks + tm.archived]
+            if initial_task in all_texts:
+                continue
+            tm.add_task(initial_task)
+            added += 1
+        print(f"✓ Added task to {added}/{len(projects)} projects: {initial_task}")
+        return
+
+    if initial_task:
+        task_manager.add_task(initial_task)
+        location = project_name or Path.cwd().name
+
+        if is_global and category:
+            print(f"✓ Added task to global ({category}): {initial_task}")
+        elif category:
+            print(f"✓ Added task to {location} ({category}): {initial_task}")
+        else:
+            print(f"✓ Added task to {location}: {initial_task}")
+
+
+def main():
+    """Entry point: parse flags, dispatch CLI commands, or start TUI."""
+    registry = ProjectRegistry()
+    args = sys.argv[1:]
+
+    # --help is always checked first
+    if '--help' in args or '-h' in args:
+        display_help()
+        return
+
+    args, broadcast_all, explicit_global, category = _parse_flags(args)
+
+    # One-shot CLI commands (--list-projects, --archive, --today, etc.)
+    if handle_cli_args(args, registry, category, explicit_global):
+        return
+
+    # Resolve project routing and initial task text
+    target_dir, project_name, initial_task = _resolve_project_and_task(args, registry)
+
+    is_global = _resolve_global(category, explicit_global, target_dir)
+
+    # Set up TaskManager and CommandHandler
+    task_manager = TaskManager(
+        directory=target_dir,
+        category=category,
+        is_global=is_global,
+        project_registry=registry,
+    )
+    command_handler = CommandHandler(task_manager, registry)
+
+    # Auto-register project if opened with .jot.json but not in registry
+    proj_dir = task_manager.project_dir
+    if (
+        not is_global
+        and (proj_dir / '.jot.json').exists()
+        and not registry.is_path_registered(proj_dir)
+    ):
+        registry.register_project(proj_dir.name, str(proj_dir))
+
+    # Auto-transfer stale tasks to backlog
+    auto_cfg = load_auto_backlog_config()
+    if auto_cfg.get('enabled', True) and category != auto_cfg.get('backlog_category', 'backlog'):
+        task_manager.transfer_old_tasks_to_backlog(
+            age_threshold_days=auto_cfg.get('age_threshold_days', 30),
+            backlog_category=auto_cfg.get('backlog_category', 'backlog'),
+        )
+
+    task_manager.ensure_default_task()
+
+    # If a task was supplied on the command line, add it and exit
+    if initial_task or broadcast_all:
+        _handle_initial_task(
+            task_manager,
+            initial_task,
+            broadcast_all,
+            registry,
+            project_name,
+            is_global,
+            category,
+        )
+        return
+
+    # Launch the interactive TUI
+    from jot.app import App
+
+    app = App(task_manager, command_handler, registry, target_dir, project_name)
+    app.run()

{jott_cli-0.8.1 → jott_cli-0.8.2}/jot/ui/display_help.py

@@ -257,9 +257,10 @@ def display_categorized_shortcuts():
 
 def display_help():
     """Display comprehensive help information."""
+    from jot import __version__
     help_text = f"""
 {BOLD}Jott - Simple Interactive Task List{RESET}
-{DIM}Version 0.7.1{RESET}
+{DIM}Version {__version__}{RESET}
 
 {BOLD}BASIC USAGE:{RESET}
   jott                      Start interactive task manager (current project)

{jott_cli-0.8.1 → jott_cli-0.8.2/jott_cli.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: jott-cli
-Version: 0.8.1
+Version: 0.8.2
 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.8.1 → jott_cli-0.8.2}/jott_cli.egg-info/SOURCES.txt

@@ -6,6 +6,7 @@ jot/__init__.py
 jot/_app_navigation_mixin.py
 jot/_dispatch_mixin.py
 jot/app.py
+jot/main.py
 jot/categories/__init__.py
 jot/categories/config.py
 jot/categories/manager.py
@@ -95,6 +96,7 @@ tests/test_github.py
 tests/test_highlight.py
 tests/test_input.py
 tests/test_jot.py
+tests/test_main_entry_point.py
 tests/test_notes_tempfile_location.py
 tests/test_picker.py
 tests/test_state_palette.py

{jott_cli-0.8.1 → jott_cli-0.8.2}/pyproject.toml

@@ -7,7 +7,7 @@ include = ["jot", "jot.*"]
 
 [project]
 name = "jott-cli"
-version = "0.8.1"
+version = "0.8.2"
 description = "Feature-rich interactive CLI task manager with AI integration, calendar sync, and keyword automation"
 readme = {file = "README.md", content-type = "text/markdown"}
 requires-python = ">=3.6"

{jott_cli-0.8.1 → jott_cli-0.8.2}/tests/test_jot.py

@@ -3390,14 +3390,7 @@ class TestImportIntegrity:
     def test_cli_broadcast_requires_confirmation(self):
         """CLI --all broadcast requires y confirmation, N cancels"""
         from unittest.mock import patch
-        import importlib.util
-
-        spec = importlib.util.spec_from_file_location(
-            "jot_main", str(Path(__file__).parent.parent / "jot.py")
-        )
-        jot_main = importlib.util.module_from_spec(spec)
-        spec.loader.exec_module(jot_main)
-        _handle_initial_task = jot_main._handle_initial_task
+        from jot.main import _handle_initial_task
 
         with tempfile.TemporaryDirectory() as tmpdir:
             tmpdir = Path(tmpdir)

jott_cli-0.8.2/tests/test_main_entry_point.py

@@ -0,0 +1,84 @@
+#!/usr/bin/env python3
+"""Regression tests for the package entry point.
+
+Earlier versions used a dynamic-import bridge that loaded main() from
+the repo-root jot.py script via spec_from_file_location. That worked
+locally (where jot.py sat next to the jot/ package) but failed under
+pip install because jot.py was not part of the wheel:
+
+    FileNotFoundError: '.../site-packages/jot.py'
+
+The fix moved main() into jot/main.py so the console script resolves
+through a real package submodule.
+"""
+
+import importlib
+import subprocess
+import sys
+from pathlib import Path
+
+
+class TestMainEntryPoint:
+    def test_main_is_a_real_package_submodule(self):
+        """jot.main must exist as a real importable submodule, not a
+        path-loaded shim. Importing it must not depend on any file
+        outside site-packages.
+        """
+        import importlib
+        main_module = importlib.import_module('jot.main')
+        main_path = Path(main_module.__file__).resolve()
+        assert main_path.name == 'main.py'
+        assert main_path.parent.name == 'jot', (
+            f"jot.main should live inside the jot/ package, "
+            f"got {main_path}"
+        )
+
+    def test_main_is_exported_from_package(self):
+        """`from jot import main` must yield a callable."""
+        # Reload to ensure we exercise the real import path.
+        if 'jot' in sys.modules:
+            importlib.reload(sys.modules['jot'])
+        from jot import main
+        assert callable(main)
+
+    def test_init_does_not_use_path_based_loader(self):
+        """Guard against re-introduction of the dynamic bridge."""
+        import jot
+        init_src = Path(jot.__file__).read_text()
+        assert 'spec_from_file_location' not in init_src, (
+            "jot/__init__.py must not load main from a file path; "
+            "it should import jot.main as a normal submodule"
+        )
+
+    def test_console_entry_point_resolves(self):
+        """Simulate what `jott` does: `import jot; jot.main` is the
+        target referenced by pyproject.toml's console_scripts entry.
+        """
+        import jot
+        assert hasattr(jot, 'main')
+        assert callable(jot.main)
+
+
+class TestInstalledLayout:
+    """Verify the layout that pip install produces. Skips silently if
+    we can't find a wheel to inspect (e.g., fresh checkout pre-build).
+    """
+
+    def test_built_wheel_contains_main_module(self):
+        dist = Path(__file__).resolve().parents[1] / 'dist'
+        if not dist.exists():
+            return  # no build artifacts; skip
+        wheels = sorted(dist.glob('jott_cli-*.whl'))
+        if not wheels:
+            return
+        latest = wheels[-1]
+
+        result = subprocess.run(
+            ['unzip', '-l', str(latest)],
+            capture_output=True, text=True,
+        )
+        listing = result.stdout
+        assert 'jot/main.py' in listing, (
+            f"wheel {latest.name} is missing jot/main.py; the entry "
+            f"point will fail on install. Listing:\n{listing}"
+        )