jott-cli 0.6.0__tar.gz → 0.7.0__tar.gz

{jott_cli-0.6.0/jott_cli.egg-info → jott_cli-0.7.0}/PKG-INFO

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

@@ -7,7 +7,7 @@ import importlib.util
 import os
 from pathlib import Path
 
-__version__ = "0.6.0"
+__version__ = "0.7.0"
 
 # 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.

{jott_cli-0.6.0 → jott_cli-0.7.0}/jot/_dispatch_mixin.py

@@ -276,6 +276,10 @@ class DispatchMixin:
             self._toggle_collapse()
             st.input_buffer = ""
             return
+        if second == 'd':
+            self.command_handler.duplicate_task()
+            st.input_buffer = ""
+            return
         if second == 'c':
             self.command_handler.copy_to_clipboard()
             st.input_buffer = ""
@@ -381,6 +385,38 @@ class DispatchMixin:
             self._handle_switch_project()
             st.input_buffer = ""
             return
+        if second == 'A':
+            self.command_handler.ask_claude()
+            st.input_buffer = ""
+            return
+        if second == 'C':
+            self.command_handler.launch_claude()
+            st.input_buffer = ""
+            return
+        if second == 'v':
+            self.command_handler.send_to_local_claude()
+            st.input_buffer = ""
+            return
+        if second == 'V':
+            self.command_handler.send_to_claude()
+            st.input_buffer = ""
+            return
+        if second == 'X':
+            self.command_handler.execute_claude()
+            st.input_buffer = ""
+            return
+        if second == 'I':
+            self.command_handler.import_from_github()
+            st.input_buffer = ""
+            return
+        if second == 'H':
+            self.command_handler.export_to_github()
+            st.input_buffer = ""
+            return
+        if second == 'D':
+            self.command_handler.close_github_issue()
+            st.input_buffer = ""
+            return
         # Not a chord — treat '.' as normal input
         st.input_buffer += '.'
         if second and second != '.':

{jott_cli-0.6.0 → jott_cli-0.7.0}/jot/app.py

@@ -104,6 +104,7 @@ class App(DispatchMixin, AppNavigationMixin):
                 tasks_to_display = self._prepare_tasks()
                 self._render(tasks_to_display)
                 self._needs_render = False
+                self._clear_terminal_claude_status()
             else:
                 tasks_to_display = self._prepare_tasks()
 
@@ -267,6 +268,7 @@ class App(DispatchMixin, AppNavigationMixin):
                     match_positions=st.match_positions,
                     collapsed_parents=st.collapsed_parents,
                     all_tasks=all_tasks,
+                    claude_status=self.command_handler._claude_status,
                 )
 
             sys.stdout.write('\033[?25h')
@@ -286,6 +288,12 @@ class App(DispatchMixin, AppNavigationMixin):
     # Auto-refresh & paste
     # ------------------------------------------------------------------
 
+    def _clear_terminal_claude_status(self):
+        """Clear 'done'/'error' statuses after one render cycle."""
+        status = self.command_handler._claude_status
+        if status and status not in ("thinking...", "editing..."):
+            self.command_handler._claude_status = ""
+
     def _handle_auto_refresh(self, key):
         """Detect external file changes on timeout."""
         if key is not None:

jott_cli-0.7.0/jot/commands/_claude_mixin.py

@@ -0,0 +1,390 @@
+"""Claude Code launch mixin — spawn Claude in a tmux window with task context."""
+
+import os
+import subprocess
+import threading
+import time
+from datetime import datetime
+
+from jot.ui.styles import RESET, CYAN, DIM
+
+
+class ClaudeMixin:
+    """Launch Claude Code in a new tmux window with current task."""
+
+    _claude_status = ""  # shared status: "thinking...", "editing...", etc.
+
+    def launch_claude(self):
+        """Open new tmux window, start Claude Code, send current task."""
+        current_task = self.task_manager.get_current_task()
+        if not current_task:
+            print("\n\u2717 No current task selected")
+            time.sleep(0.5)
+            return True
+
+        if not os.environ.get('TMUX'):
+            print("\n\u2717 Not in a tmux session")
+            time.sleep(0.5)
+            return True
+
+        task_text = current_task['text']
+        task_id = current_task['id']
+        window_name = f"claude-{task_id}"
+
+        try:
+            subprocess.run(
+                ['tmux', 'new-window', '-n', window_name, 'claude'],
+                check=True,
+                stdout=subprocess.DEVNULL,
+                stderr=subprocess.DEVNULL,
+            )
+        except (subprocess.CalledProcessError, FileNotFoundError) as e:
+            print(f"\n\u2717 Failed to create tmux window: {e}")
+            time.sleep(0.5)
+            return True
+
+        prompt_found = self._wait_for_claude_prompt(window_name)
+        self._send_to_tmux_target(window_name, task_text)
+
+        if prompt_found:
+            print(f"\n{CYAN}\u2713 Launched Claude with: "
+                  f"{task_text[:50]}{'...' if len(task_text) > 50 else ''}"
+                  f"{RESET}")
+        else:
+            print(f"\n{CYAN}\u2713 Sent task to Claude "
+                  f"(prompt not confirmed){RESET}")
+
+        time.sleep(0.5)
+        return True
+
+    def send_to_claude(self):
+        """Send current task text to an existing Claude pane."""
+        current_task = self.task_manager.get_current_task()
+        if not current_task:
+            print("\n\u2717 No current task selected")
+            time.sleep(0.5)
+            return True
+
+        if not os.environ.get('TMUX'):
+            print("\n\u2717 Not in a tmux session")
+            time.sleep(0.5)
+            return True
+
+        panes = self._find_claude_panes()
+        if not panes:
+            print("\n\u2717 No Claude Code panes found")
+            time.sleep(0.5)
+            return True
+
+        if len(panes) == 1:
+            target = panes[0]
+        else:
+            target = self._pick_claude_pane(panes)
+            if not target:
+                return True
+
+        task_text = current_task['text']
+
+        prompt_found = self._wait_for_claude_prompt(target, timeout=3)
+        self._send_to_tmux_target(target, task_text)
+
+        label = target.rsplit(':', 1)[0]  # session:window
+        if prompt_found:
+            print(f"\n{CYAN}\u2713 Sent to {label}: "
+                  f"{task_text[:50]}{'...' if len(task_text) > 50 else ''}"
+                  f"{RESET}")
+        else:
+            print(f"\n{CYAN}\u2713 Sent to {label} "
+                  f"(prompt not confirmed){RESET}")
+
+        time.sleep(0.5)
+        return True
+
+    def send_to_local_claude(self):
+        """Send current task text to Claude in the current tmux session."""
+        current_task = self.task_manager.get_current_task()
+        if not current_task:
+            print("\n\u2717 No current task selected")
+            time.sleep(0.5)
+            return True
+
+        if not os.environ.get('TMUX'):
+            print("\n\u2717 Not in a tmux session")
+            time.sleep(0.5)
+            return True
+
+        session = self._current_tmux_session()
+        if not session:
+            print("\n\u2717 Could not detect tmux session")
+            time.sleep(0.5)
+            return True
+
+        panes = self._find_claude_panes(session_filter=session)
+        if not panes:
+            print(f"\n\u2717 No Claude pane in session '{session}'")
+            time.sleep(0.5)
+            return True
+
+        target = panes[0]
+        task_text = current_task['text']
+
+        prompt_found = self._wait_for_claude_prompt(target, timeout=3)
+        self._send_to_tmux_target(target, task_text)
+
+        if prompt_found:
+            print(f"\n{CYAN}\u2713 Sent to {session}: "
+                  f"{task_text[:50]}{'...' if len(task_text) > 50 else ''}"
+                  f"{RESET}")
+        else:
+            print(f"\n{CYAN}\u2713 Sent to {session} "
+                  f"(prompt not confirmed){RESET}")
+
+        time.sleep(0.5)
+        return True
+
+    def ask_claude(self):
+        """Send current task to Claude Code in background, write response to notes."""
+        current_task = self.task_manager.get_current_task()
+        if not current_task:
+            print("\n\u2717 No current task selected")
+            time.sleep(0.5)
+            return True
+
+        task_text = current_task['text']
+        task_id = current_task['id']
+        existing_notes = self.task_manager.get_task_notes(task_id) or ''
+
+        self._claude_status = "thinking..."
+        print(f"\n{CYAN}\u2713 Asking Claude about: "
+              f"{task_text[:50]}{'...' if len(task_text) > 50 else ''}"
+              f"{RESET}")
+        print(f"  {DIM}Response will be written to task notes{RESET}")
+        time.sleep(0.3)
+
+        thread = threading.Thread(
+            target=self._run_claude_background,
+            args=(task_id, task_text, existing_notes),
+            daemon=True,
+        )
+        thread.start()
+        return True
+
+    def execute_claude(self):
+        """Execute Claude with edit permissions using task notes as context."""
+        current_task = self.task_manager.get_current_task()
+        if not current_task:
+            print("\n\u2717 No current task selected")
+            time.sleep(0.5)
+            return True
+
+        task_text = current_task['text']
+        task_id = current_task['id']
+        existing_notes = self.task_manager.get_task_notes(task_id) or ''
+
+        if not existing_notes.strip():
+            print(f"\n\u2717 No notes on task; run {CYAN}.A{RESET} first")
+            time.sleep(0.8)
+            return True
+
+        self._claude_status = "editing..."
+        print(f"\n{CYAN}\u2713 Executing Claude with edit permissions{RESET}")
+        print(f"  {DIM}Task: {task_text[:50]}"
+              f"{'...' if len(task_text) > 50 else ''}{RESET}")
+        time.sleep(0.3)
+
+        thread = threading.Thread(
+            target=self._run_claude_background,
+            args=(task_id, task_text, existing_notes, True),
+            daemon=True,
+        )
+        thread.start()
+        return True
+
+    def _run_claude_background(self, task_id, task_text, existing_notes,
+                               allow_edits=False):
+        """Run claude -p in background and append response to task notes."""
+        try:
+            if existing_notes.strip():
+                prompt = (f"Task: {task_text}\n\n"
+                          f"Existing notes:\n{existing_notes}")
+            else:
+                prompt = task_text
+
+            cmd = [
+                'claude', '-p', '--model', 'sonnet',
+                '--permission-mode', 'dontAsk',
+                '--allowedTools', 'Read',
+            ]
+            if allow_edits:
+                cmd = [
+                    'claude', '-p', '--model', 'sonnet',
+                    '--permission-mode', 'dontAsk',
+                    '--allowedTools', 'Edit', 'Read', 'Write',
+                    'Bash(git diff)', 'Bash(git status)',
+                ]
+
+            result = subprocess.run(
+                cmd,
+                input=prompt,
+                capture_output=True,
+                text=True,
+                timeout=120,
+            )
+            response = result.stdout.strip()
+            if not response:
+                stderr = result.stderr.strip()
+                if stderr:
+                    self._claude_status = "error"
+                    self._append_claude_note(
+                        task_id, existing_notes,
+                        f"[error: {stderr[:200]}]")
+                else:
+                    self._claude_status = "done (empty response)"
+                return
+
+            self._append_claude_note(task_id, existing_notes, response)
+            self._claude_status = "done"
+
+        except subprocess.TimeoutExpired:
+            self._claude_status = "timed out"
+            self._append_claude_note(
+                task_id, existing_notes, "[timed out after 120s]")
+        except FileNotFoundError:
+            self._claude_status = "error: claude not found"
+        except subprocess.CalledProcessError as e:
+            self._claude_status = "error"
+            self._append_claude_note(
+                task_id, existing_notes,
+                f"[process error: {e.returncode}]")
+
+    def _append_claude_note(self, task_id, existing_notes, content):
+        """Append a timestamped Claude entry to task notes."""
+        timestamp = datetime.now().strftime('%Y-%m-%d %H:%M')
+        entry = f"* Claude ({timestamp})\n{content}\n"
+        if existing_notes.strip():
+            updated = existing_notes.rstrip('\n') + '\n\n' + entry
+        else:
+            updated = entry
+        self.task_manager.set_task_notes(task_id, updated)
+
+    def _current_tmux_session(self):
+        """Get the name of the current tmux session."""
+        try:
+            result = subprocess.run(
+                ['tmux', 'display-message', '-p', '#{session_name}'],
+                capture_output=True, text=True,
+            )
+            return result.stdout.strip() or None
+        except (subprocess.CalledProcessError, FileNotFoundError):
+            return None
+
+    def _find_claude_panes(self, session_filter=None):
+        """Find tmux panes running Claude Code across all sessions.
+
+        Claude Code runs as node with python3.12 + node + zsh sibling
+        panes. We identify it by capturing pane content and looking for
+        Claude's prompt indicator.
+        """
+        try:
+            result = subprocess.run(
+                ['tmux', 'list-panes', '-a', '-F',
+                 '#{session_name}:#{window_index}.#{pane_index} '
+                 '#{pane_current_command}'],
+                capture_output=True, text=True,
+            )
+        except (subprocess.CalledProcessError, FileNotFoundError):
+            return []
+
+        # Candidate panes: node processes (Claude Code runs as node)
+        candidates = []
+        for line in result.stdout.strip().splitlines():
+            parts = line.split(' ', 1)
+            if len(parts) == 2 and parts[1] == 'node':
+                pane_id = parts[0]
+                if session_filter:
+                    sess = pane_id.split(':')[0]
+                    if sess != session_filter:
+                        continue
+                candidates.append(pane_id)
+
+        # Check each candidate for Claude's prompt in pane content
+        claude_panes = []
+        for pane_id in candidates:
+            try:
+                capture = subprocess.run(
+                    ['tmux', 'capture-pane', '-t', pane_id, '-p'],
+                    capture_output=True, text=True,
+                )
+                content = capture.stdout
+                if self._looks_like_claude(content):
+                    claude_panes.append(pane_id)
+            except (subprocess.CalledProcessError, FileNotFoundError):
+                pass
+
+        return claude_panes
+
+    def _looks_like_claude(self, content):
+        """Check if pane content looks like a Claude Code session."""
+        for line in content.splitlines():
+            stripped = line.strip()
+            # Claude's input prompt
+            if stripped.startswith('\u276f') or stripped.startswith('\u2771'):
+                return True
+            # Status line markers
+            if 'Opus' in stripped or 'Sonnet' in stripped:
+                return True
+            if 'claude' in stripped.lower() and (
+                    'context' in stripped.lower()
+                    or 'token' in stripped.lower()):
+                return True
+        return False
+
+    def _pick_claude_pane(self, panes):
+        """Show picker for multiple Claude panes, return selection."""
+        from jot.ui.picker import quick_picker, PickerItem
+
+        items = [
+            PickerItem(
+                value=pane_id,
+                label=pane_id.rsplit(':', 1)[0],  # session:window
+                annotation=pane_id,
+            )
+            for pane_id in panes
+        ]
+        result = quick_picker(items, prompt="Send to which Claude session")
+        if result and result.value:
+            return result.value
+        return None
+
+    def _send_to_tmux_target(self, target, text):
+        """Send text + Enter to a tmux target."""
+        subprocess.run(
+            ['tmux', 'send-keys', '-t', target, '-l', text],
+            stdout=subprocess.DEVNULL,
+            stderr=subprocess.DEVNULL,
+        )
+        subprocess.run(
+            ['tmux', 'send-keys', '-t', target, 'Enter'],
+            stdout=subprocess.DEVNULL,
+            stderr=subprocess.DEVNULL,
+        )
+
+    def _wait_for_claude_prompt(self, target, timeout=10, interval=0.3):
+        """Poll tmux pane until Claude's input prompt appears."""
+        deadline = time.time() + timeout
+        while time.time() < deadline:
+            try:
+                result = subprocess.run(
+                    ['tmux', 'capture-pane', '-t', target, '-p'],
+                    capture_output=True, text=True,
+                )
+                for line in result.stdout.splitlines():
+                    stripped = line.strip()
+                    if stripped.startswith('>') or stripped.endswith('>'):
+                        return True
+                    if stripped.startswith('\u276f'):
+                        return True
+            except (subprocess.CalledProcessError, FileNotFoundError):
+                pass
+            time.sleep(interval)
+        return False

{jott_cli-0.6.0 → jott_cli-0.7.0}/jot/commands/_core_mixin.py

@@ -61,6 +61,22 @@ class CoreMixin:
             print(f"\n✗ Failed to mark task")
         return True
 
+    def duplicate_task(self):
+        """Duplicate the current task."""
+        current_task = self.task_manager.get_current_task()
+        if not current_task:
+            print("\n\u2717 No current task selected")
+            return True
+
+        new_id = self.task_manager.duplicate_task(current_task['id'])
+        if new_id:
+            text = current_task['text']
+            display = text if len(text) <= 50 else text[:47] + '...'
+            print(f"\n{CYAN}\u2713 Duplicated as #{new_id}: {display}{RESET}")
+        else:
+            print("\n\u2717 Failed to duplicate task")
+        return True
+
     def fix_duplicate_ids_interactive(self):
         """Check for and fix duplicate task IDs (Shift+1)"""
         all_tasks = self.task_manager.tasks + self.task_manager.archived