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

{jott_cli-0.7.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.7.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.7.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.7.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.7.1 → jott_cli-0.8.2}/jot/app.py

@@ -84,6 +84,11 @@ class App(DispatchMixin, AppNavigationMixin):
             os.path.getmtime(task_manager.storage_file)
             if task_manager.storage_file.exists() else 0)
 
+        try:
+            task_manager._migrate_legacy_deleted_notes()
+        except Exception as e:
+            print(f"Warning: deleted-notes migration failed: {e}")
+
     # ------------------------------------------------------------------
     # Public entry point
     # ------------------------------------------------------------------

{jott_cli-0.7.1 → jott_cli-0.8.2}/jot/commands/_metadata_mixin.py

@@ -7,7 +7,7 @@ from jot.ui.picker import PickerItem, quick_picker, fuzzy_picker
 from jot.ui.styles import (
     RESET, BOLD, DIM, GREEN, RED,
     PRIORITY_COLORS, PRIORITY_SYMBOLS, STATUS_COLORS, STATUS_SYMBOLS,
-    HIGHLIGHT_COLORS,
+    HIGHLIGHT_COLORS, STATE_ORDER, STATE_COLORS,
 )
 from jot.ui.input import restore_terminal
 
@@ -125,20 +125,29 @@ class MetadataMixin:
         return True
 
     def toggle_highlight(self):
-        """Pick a highlight color for the current task, or clear it."""
+        """Pick a task state (color-coded) for the current task."""
         current_task = self.task_manager.get_current_task()
         if not current_task:
             return True
 
-        items = [PickerItem(value="_clear", label="none (clear)", color=DIM)]
-        for name, fmt in HIGHLIGHT_COLORS.items():
-            items.append(PickerItem(
-                value=name, label=name, color=fmt,
-            ))
+        items = []
+        for state in STATE_ORDER:
+            color_key = STATE_COLORS[state]
+            if color_key is None:
+                items.append(PickerItem(
+                    value="_clear", label="none", color=DIM,
+                    annotation=state,
+                ))
+            else:
+                items.append(PickerItem(
+                    value=color_key, label=color_key,
+                    color=HIGHLIGHT_COLORS[color_key],
+                    annotation=state,
+                ))
 
         result = quick_picker(
             items,
-            prompt=f"Highlight color for: {current_task['text']}",
+            prompt=f"State for: {current_task['text']}",
         )
 
         if result.value is None:
@@ -146,11 +155,13 @@ class MetadataMixin:
 
         if result.value == "_clear":
             self.task_manager.set_highlight(color=None)
-            print(f"\n{GREEN}✓{RESET} Highlight cleared")
+            print(f"\n{GREEN}✓{RESET} State cleared (backlog)")
         else:
             self.task_manager.set_highlight(color=result.value)
             fmt = HIGHLIGHT_COLORS[result.value]
-            print(f"\n{GREEN}✓{RESET} Highlight set to {fmt} {result.value} {RESET}")
+            from jot.ui.styles import COLOR_TO_STATE
+            state_name = COLOR_TO_STATE.get(result.value, result.value)
+            print(f"\n{GREEN}✓{RESET} State: {fmt} {state_name} {RESET}")
 
         print("\nPress Enter to continue...", end='', flush=True)
         restore_terminal()

{jott_cli-0.7.1 → jott_cli-0.8.2}/jot/core/_delete_mixin.py

@@ -1,12 +1,55 @@
-"""Delete mixin — archive, permanent delete, notes export."""
+"""Delete mixin, archive, permanent delete, notes export."""
 
 import os
+import re
 from datetime import datetime
 
 
+DELETED_NOTES_DIR = ".jot-deleted-notes"
+_DELETED_NOTES_FILENAME_RE = re.compile(
+    r"^TASK-\d+-notes-\d{8}_\d{6}\.org$"
+)
+
+
 class DeleteMixin:
     """Task removal, archival, and notes preservation."""
 
+    def _migrate_legacy_deleted_notes(self):
+        """Move stray TASK-<id>-notes-<ts>.org files from project_dir
+        into the DELETED_NOTES_DIR subdirectory. Idempotent: a no-op
+        when no matching files exist at the project root.
+        """
+        try:
+            entries = list(self.project_dir.iterdir())
+        except (OSError, AttributeError):
+            return 0
+
+        matches = [
+            p for p in entries
+            if p.is_file() and _DELETED_NOTES_FILENAME_RE.match(p.name)
+        ]
+        if not matches:
+            return 0
+
+        dest_dir = self.project_dir / DELETED_NOTES_DIR
+        try:
+            dest_dir.mkdir(exist_ok=True)
+        except OSError as e:
+            print(f"Warning: could not create {dest_dir}: {e}")
+            return 0
+
+        moved = 0
+        for src in matches:
+            dest = dest_dir / src.name
+            if dest.exists():
+                continue
+            try:
+                src.rename(dest)
+                moved += 1
+            except OSError as e:
+                print(f"Warning: could not move {src.name}: {e}")
+        return moved
+
     def _unlink_children(self, task_id):
         """Remove parent:{task_id} labels from all children."""
         parent_label = f"parent:{task_id}"
@@ -131,7 +174,13 @@ class DeleteMixin:
         )
 
         filename = f"TASK-{task_id}-notes-{now.strftime('%Y%m%d_%H%M%S')}.org"
-        org_file_path = self.project_dir / filename
+        dest_dir = self.project_dir / DELETED_NOTES_DIR
+        try:
+            dest_dir.mkdir(exist_ok=True)
+        except OSError as e:
+            print(f"Warning: Could not create {dest_dir}: {e}")
+            return None
+        org_file_path = dest_dir / filename
 
         try:
             with open(org_file_path, 'w') as f:

{jott_cli-0.7.1 → jott_cli-0.8.2}/jot/core/_metadata_mixin.py

@@ -3,6 +3,18 @@
 from datetime import datetime, timezone
 
 
+# One-way mapping from legacy status values to highlight color keys.
+# Setting status auto-paints the highlight; the reverse is NOT applied.
+# Status is being deprecated in favor of the richer state palette;
+# this exists so the legacy `* status` picker still does something useful.
+_STATUS_TO_HIGHLIGHT = {
+    'todo': 'red',
+    'in-progress': 'orange',
+    'blocked': 'burnt',
+    'done': 'yellow',
+}
+
+
 class MetadataMixin:
     """Set task metadata: current flag, agent, day, priority, status, tally."""
 
@@ -118,6 +130,9 @@ class MetadataMixin:
                     task['done'] = True
                 elif task.get('done', False):
                     task['done'] = False
+                color = _STATUS_TO_HIGHLIGHT.get(status)
+                if color:
+                    task['highlight'] = color
                 self._save_tasks()
                 return True
         return False

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.7.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.7.1 → jott_cli-0.8.2}/jot/ui/styles.py

@@ -49,26 +49,65 @@ BLACK = '\033[30m'
 # Background colors
 BG_YELLOW = '\033[103m'
 BG_ORANGE = '\033[48;5;208m'
+BG_BURNT_ORANGE = '\033[48;5;166m'
 BG_MAGENTA = '\033[105m'
 BG_GRAY = '\033[100m'
 BG_DARK_GRAY = '\033[48;5;236m'
 BG_CYAN = '\033[106m'
+BG_BLUE = '\033[48;5;33m'
 BG_RED = '\033[101m'
 BG_GREEN = '\033[102m'
 
-# Semantic mappings — highlight color palette
+# Semantic mappings, highlight color palette.
+# Each color maps to a task state in STATE_HIGHLIGHTS below; the legacy
+# `status` field is being deprecated in favor of these state-bearing
+# highlights.
 HIGHLIGHT_COLORS = {
     'gray': WHITE + BG_DARK_GRAY,
-    'yellow': BLACK + BG_YELLOW,
-    'orange': BLACK + BG_ORANGE,
     'magenta': WHITE + BG_MAGENTA,
     'cyan': BLACK + BG_CYAN,
     'red': WHITE + BG_RED,
+    'orange': BLACK + BG_ORANGE,
+    'burnt': WHITE + BG_BURNT_ORANGE,
+    'yellow': BLACK + BG_YELLOW,
+    'blue': WHITE + BG_BLUE,
     'green': BLACK + BG_GREEN,
 }
-HIGHLIGHT_DEFAULT = 'yellow'
+HIGHLIGHT_DEFAULT = 'gray'
 HIGHLIGHT_FMT = HIGHLIGHT_COLORS[HIGHLIGHT_DEFAULT]
 
+# Semantic mappings, task state pipeline.
+# Ordered from earliest to latest; STATE_COLORS[state] is the
+# highlight-color key (looks up into HIGHLIGHT_COLORS), or None for
+# the unhighlighted "backlog" state.
+STATE_ORDER = [
+    'backlog',
+    'needs-review',
+    'in-review',
+    'ready',
+    'todo',
+    'doing',
+    'blocked',
+    'done',
+    'shipping',
+    'complete',
+]
+STATE_COLORS = {
+    'backlog': None,
+    'needs-review': 'gray',
+    'in-review': 'magenta',
+    'ready': 'cyan',
+    'todo': 'red',
+    'doing': 'orange',
+    'blocked': 'burnt',
+    'done': 'yellow',
+    'shipping': 'blue',
+    'complete': 'green',
+}
+# Reverse lookup: highlight-color key → state name (for one-way
+# inference from the legacy color field if ever needed).
+COLOR_TO_STATE = {v: k for k, v in STATE_COLORS.items() if v is not None}
+
 # Semantic mappings — priority
 PRIORITY_COLORS = {
     'none': DIM,

{jott_cli-0.7.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.7.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.7.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
@@ -84,7 +85,9 @@ jott_cli.egg-info/dependency_links.txt
 jott_cli.egg-info/entry_points.txt
 jott_cli.egg-info/requires.txt
 jott_cli.egg-info/top_level.txt
+tests/test_claude_org_prompt.py
 tests/test_command_handler.py
+tests/test_deleted_notes_dir.py
 tests/test_dispatch.py
 tests/test_edit_edge_cases.py
 tests/test_fuzzy_search.py
@@ -93,7 +96,10 @@ 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
 tests/test_styles.py
 tests/test_subtask_notes.py
 tests/test_terminal_wrap.py

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

@@ -7,7 +7,7 @@ include = ["jot", "jot.*"]
 
 [project]
 name = "jott-cli"
-version = "0.7.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.2/tests/test_claude_org_prompt.py

@@ -0,0 +1,90 @@
+#!/usr/bin/env python3
+"""Tests for org-mode formatting instruction appended to Claude prompts."""
+
+import tempfile
+from pathlib import Path
+from types import SimpleNamespace
+from unittest.mock import patch
+
+from jot import TaskManager
+from jot.commands.handler import CommandHandler
+from jot.commands._claude_mixin import _ORG_OUTPUT_INSTRUCTION
+
+
+def _make_handler(tmpdir: Path):
+    (tmpdir / ".jot-registry.json").write_text("{}")
+    tm = TaskManager(storage_file='.jot.json', directory=str(tmpdir))
+    return tm, CommandHandler(tm)
+
+
+def _fake_subprocess_result(stdout="* Result\nbody\n"):
+    return SimpleNamespace(stdout=stdout, stderr="", returncode=0)
+
+
+class TestOrgOutputInstruction:
+    def test_instruction_constant_mentions_org_markers(self):
+        # Sanity: ensure the constant actually directs to org-mode output.
+        assert '#+begin_src' in _ORG_OUTPUT_INSTRUCTION
+        assert 'Do NOT use markdown' in _ORG_OUTPUT_INSTRUCTION
+        assert '~symbol~' in _ORG_OUTPUT_INSTRUCTION or '=literal=' in _ORG_OUTPUT_INSTRUCTION
+
+    def test_instruction_appended_when_no_existing_notes(self):
+        with tempfile.TemporaryDirectory() as raw:
+            tmpdir = Path(raw)
+            tm, handler = _make_handler(tmpdir)
+            tm.add_task("write a fizzbuzz")
+            task = tm.tasks[0]
+            with patch(
+                'jot.commands._claude_mixin.subprocess.run',
+                return_value=_fake_subprocess_result(),
+            ) as mocked:
+                handler._run_claude_background(
+                    task['id'], task['text'], existing_notes='',
+                    allow_edits=False,
+                )
+
+            assert mocked.called
+            prompt = mocked.call_args.kwargs['input']
+            assert prompt.startswith("write a fizzbuzz")
+            assert prompt.endswith(_ORG_OUTPUT_INSTRUCTION)
+
+    def test_instruction_appended_when_existing_notes_present(self):
+        with tempfile.TemporaryDirectory() as raw:
+            tmpdir = Path(raw)
+            tm, handler = _make_handler(tmpdir)
+            tm.add_task("rewrite the parser")
+            task = tm.tasks[0]
+            with patch(
+                'jot.commands._claude_mixin.subprocess.run',
+                return_value=_fake_subprocess_result(),
+            ) as mocked:
+                handler._run_claude_background(
+                    task['id'], task['text'],
+                    existing_notes='prior context here',
+                    allow_edits=False,
+                )
+
+            prompt = mocked.call_args.kwargs['input']
+            assert 'rewrite the parser' in prompt
+            assert 'prior context here' in prompt
+            assert prompt.endswith(_ORG_OUTPUT_INSTRUCTION)
+
+    def test_instruction_appended_in_edit_mode(self):
+        # allow_edits=True path uses a different cmd but same prompt assembly.
+        with tempfile.TemporaryDirectory() as raw:
+            tmpdir = Path(raw)
+            tm, handler = _make_handler(tmpdir)
+            tm.add_task("apply diff")
+            task = tm.tasks[0]
+            with patch(
+                'jot.commands._claude_mixin.subprocess.run',
+                return_value=_fake_subprocess_result(),
+            ) as mocked:
+                handler._run_claude_background(
+                    task['id'], task['text'],
+                    existing_notes='notes',
+                    allow_edits=True,
+                )
+
+            prompt = mocked.call_args.kwargs['input']
+            assert prompt.endswith(_ORG_OUTPUT_INSTRUCTION)