lolTasks 1.0.0__tar.gz

loltasks-1.0.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Luke J. Stephens
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

loltasks-1.0.0/MANIFEST.in

@@ -0,0 +1,3 @@
+include task_spec.md
+include README.md
+include LICENSE

loltasks-1.0.0/PKG-INFO

@@ -0,0 +1,161 @@
+Metadata-Version: 2.4
+Name: lolTasks
+Version: 1.0.0
+Summary: A terminal-based weekly task management application with advanced text editing
+Home-page: https://github.com/lstephensFederation/lolTasks
+Author: Luke J. Stephens
+Author-email: l.stephens@federation.edu.au
+License: MIT
+Project-URL: Bug Reports, https://github.com/lstephensFederation/lolTasks/issues
+Project-URL: Source, https://github.com/lstephensFederation/lolTasks
+Keywords: task management terminal curses weekly planner
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: End Users/Desktop
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.6
+Classifier: Programming Language :: Python :: 3.7
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Topic :: Utilities
+Requires-Python: >=3.6
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: keywords
+Dynamic: license
+Dynamic: license-file
+Dynamic: project-url
+Dynamic: requires-python
+Dynamic: summary
+
+# lolTasks
+
+A powerful terminal-based weekly task management application built with Python and curses.
+
+## Features
+
+- **Weekly Task Management**: Organize tasks by week with a clean, intuitive interface
+- **Advanced Text Editing**: Full-featured line editor with undo/redo, word navigation, and standard shortcuts
+- **Cross-Platform**: Works on macOS, Linux, and Windows (with appropriate terminal)
+- **Persistent Storage**: JSON-based data storage in your home directory
+- **Vim-Style Shortcuts**: Familiar key bindings for power users
+
+## Installation
+
+### From PyPI (Recommended)
+```bash
+pip install lolTasks
+```
+
+### From Source
+```bash
+git clone https://github.com/lstephensFederation/lolTasks.git
+cd lolTasks
+pip install .
+```
+
+## Usage
+
+### Basic Usage
+```bash
+lolTasks
+# or
+task
+```
+
+### Command Line Options
+```bash
+lolTasks --help  # Show help and key bindings
+```
+
+## Key Bindings
+
+### Navigation
+- `↑/↓` or `k/j`: Move selection up/down
+- `←/→` or `h/l`: Navigate to previous/next week
+- `Tab`: Cycle task state forward (TO-DO → PENDING → COMPLETED)
+- `Shift+Tab`: Cycle task state backward
+
+### Task Management
+- `a`: Add new task after selected item
+- `Enter`: Edit selected task (or week title if none selected)
+- `I`: Edit task at beginning of line (vim-style)
+- `d`: Delete selected task
+- `r`: Toggle reorder mode for moving tasks up/down
+- `Esc`: Exit edit mode
+
+### Global Actions
+- `Ctrl + U`: Undo last action
+- `Ctrl + R`: Redo last undone action
+- `n`: Move task to next week
+- `p`: Move task to previous week
+- `q`: Quit application
+
+### Text Editing (when in edit mode)
+- `Esc + U`: Undo last change (vim-style)
+- `Esc + R`: Redo last undone change
+- `Option + Left` (macOS): Skip to previous word
+- `Option + Right` (macOS): Skip to next word
+- `Ctrl + A`: Move to start of line
+- `Ctrl + E`: Move to end of line
+- `Left/Right`: Move cursor
+- `Home/End`: Move to start/end of line
+- `Backspace/Delete`: Delete characters
+- `Enter/Esc`: Save and exit edit mode
+
+## Data Storage
+
+Tasks are stored in `~/.lolTasks/weekly_tasks.json`. The application automatically creates this directory and file on first run.
+
+## Requirements
+
+- Python 3.6+
+- A terminal that supports curses (most modern terminals)
+
+## Development
+
+### Setup Development Environment
+```bash
+git clone https://github.com/lstephensFederation/lolTasks.git
+cd lolTasks
+pip install -e .
+```
+
+### Running Tests
+```bash
+# No tests implemented yet
+```
+
+## Contributing
+
+1. Fork the repository
+2. Create a feature branch
+3. Make your changes
+4. Test thoroughly
+5. Submit a pull request
+
+## License
+
+MIT License - see LICENSE file for details.
+
+## Changelog
+
+### Version 1.0.0
+- Initial release
+- Complete task management functionality
+- Advanced text editing features
+- Cross-platform compatibility
+- Comprehensive documentation
+
+## Support
+
+For issues, questions, or contributions, please visit:
+https://github.com/lstephensFederation/lolTasks

loltasks-1.0.0/README.md

@@ -0,0 +1,123 @@
+# lolTasks
+
+A powerful terminal-based weekly task management application built with Python and curses.
+
+## Features
+
+- **Weekly Task Management**: Organize tasks by week with a clean, intuitive interface
+- **Advanced Text Editing**: Full-featured line editor with undo/redo, word navigation, and standard shortcuts
+- **Cross-Platform**: Works on macOS, Linux, and Windows (with appropriate terminal)
+- **Persistent Storage**: JSON-based data storage in your home directory
+- **Vim-Style Shortcuts**: Familiar key bindings for power users
+
+## Installation
+
+### From PyPI (Recommended)
+```bash
+pip install lolTasks
+```
+
+### From Source
+```bash
+git clone https://github.com/lstephensFederation/lolTasks.git
+cd lolTasks
+pip install .
+```
+
+## Usage
+
+### Basic Usage
+```bash
+lolTasks
+# or
+task
+```
+
+### Command Line Options
+```bash
+lolTasks --help  # Show help and key bindings
+```
+
+## Key Bindings
+
+### Navigation
+- `↑/↓` or `k/j`: Move selection up/down
+- `←/→` or `h/l`: Navigate to previous/next week
+- `Tab`: Cycle task state forward (TO-DO → PENDING → COMPLETED)
+- `Shift+Tab`: Cycle task state backward
+
+### Task Management
+- `a`: Add new task after selected item
+- `Enter`: Edit selected task (or week title if none selected)
+- `I`: Edit task at beginning of line (vim-style)
+- `d`: Delete selected task
+- `r`: Toggle reorder mode for moving tasks up/down
+- `Esc`: Exit edit mode
+
+### Global Actions
+- `Ctrl + U`: Undo last action
+- `Ctrl + R`: Redo last undone action
+- `n`: Move task to next week
+- `p`: Move task to previous week
+- `q`: Quit application
+
+### Text Editing (when in edit mode)
+- `Esc + U`: Undo last change (vim-style)
+- `Esc + R`: Redo last undone change
+- `Option + Left` (macOS): Skip to previous word
+- `Option + Right` (macOS): Skip to next word
+- `Ctrl + A`: Move to start of line
+- `Ctrl + E`: Move to end of line
+- `Left/Right`: Move cursor
+- `Home/End`: Move to start/end of line
+- `Backspace/Delete`: Delete characters
+- `Enter/Esc`: Save and exit edit mode
+
+## Data Storage
+
+Tasks are stored in `~/.lolTasks/weekly_tasks.json`. The application automatically creates this directory and file on first run.
+
+## Requirements
+
+- Python 3.6+
+- A terminal that supports curses (most modern terminals)
+
+## Development
+
+### Setup Development Environment
+```bash
+git clone https://github.com/lstephensFederation/lolTasks.git
+cd lolTasks
+pip install -e .
+```
+
+### Running Tests
+```bash
+# No tests implemented yet
+```
+
+## Contributing
+
+1. Fork the repository
+2. Create a feature branch
+3. Make your changes
+4. Test thoroughly
+5. Submit a pull request
+
+## License
+
+MIT License - see LICENSE file for details.
+
+## Changelog
+
+### Version 1.0.0
+- Initial release
+- Complete task management functionality
+- Advanced text editing features
+- Cross-platform compatibility
+- Comprehensive documentation
+
+## Support
+
+For issues, questions, or contributions, please visit:
+https://github.com/lstephensFederation/lolTasks

loltasks-1.0.0/lolTasks.egg-info/PKG-INFO

@@ -0,0 +1,161 @@
+Metadata-Version: 2.4
+Name: lolTasks
+Version: 1.0.0
+Summary: A terminal-based weekly task management application with advanced text editing
+Home-page: https://github.com/lstephensFederation/lolTasks
+Author: Luke J. Stephens
+Author-email: l.stephens@federation.edu.au
+License: MIT
+Project-URL: Bug Reports, https://github.com/lstephensFederation/lolTasks/issues
+Project-URL: Source, https://github.com/lstephensFederation/lolTasks
+Keywords: task management terminal curses weekly planner
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: End Users/Desktop
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.6
+Classifier: Programming Language :: Python :: 3.7
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Topic :: Utilities
+Requires-Python: >=3.6
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: keywords
+Dynamic: license
+Dynamic: license-file
+Dynamic: project-url
+Dynamic: requires-python
+Dynamic: summary
+
+# lolTasks
+
+A powerful terminal-based weekly task management application built with Python and curses.
+
+## Features
+
+- **Weekly Task Management**: Organize tasks by week with a clean, intuitive interface
+- **Advanced Text Editing**: Full-featured line editor with undo/redo, word navigation, and standard shortcuts
+- **Cross-Platform**: Works on macOS, Linux, and Windows (with appropriate terminal)
+- **Persistent Storage**: JSON-based data storage in your home directory
+- **Vim-Style Shortcuts**: Familiar key bindings for power users
+
+## Installation
+
+### From PyPI (Recommended)
+```bash
+pip install lolTasks
+```
+
+### From Source
+```bash
+git clone https://github.com/lstephensFederation/lolTasks.git
+cd lolTasks
+pip install .
+```
+
+## Usage
+
+### Basic Usage
+```bash
+lolTasks
+# or
+task
+```
+
+### Command Line Options
+```bash
+lolTasks --help  # Show help and key bindings
+```
+
+## Key Bindings
+
+### Navigation
+- `↑/↓` or `k/j`: Move selection up/down
+- `←/→` or `h/l`: Navigate to previous/next week
+- `Tab`: Cycle task state forward (TO-DO → PENDING → COMPLETED)
+- `Shift+Tab`: Cycle task state backward
+
+### Task Management
+- `a`: Add new task after selected item
+- `Enter`: Edit selected task (or week title if none selected)
+- `I`: Edit task at beginning of line (vim-style)
+- `d`: Delete selected task
+- `r`: Toggle reorder mode for moving tasks up/down
+- `Esc`: Exit edit mode
+
+### Global Actions
+- `Ctrl + U`: Undo last action
+- `Ctrl + R`: Redo last undone action
+- `n`: Move task to next week
+- `p`: Move task to previous week
+- `q`: Quit application
+
+### Text Editing (when in edit mode)
+- `Esc + U`: Undo last change (vim-style)
+- `Esc + R`: Redo last undone change
+- `Option + Left` (macOS): Skip to previous word
+- `Option + Right` (macOS): Skip to next word
+- `Ctrl + A`: Move to start of line
+- `Ctrl + E`: Move to end of line
+- `Left/Right`: Move cursor
+- `Home/End`: Move to start/end of line
+- `Backspace/Delete`: Delete characters
+- `Enter/Esc`: Save and exit edit mode
+
+## Data Storage
+
+Tasks are stored in `~/.lolTasks/weekly_tasks.json`. The application automatically creates this directory and file on first run.
+
+## Requirements
+
+- Python 3.6+
+- A terminal that supports curses (most modern terminals)
+
+## Development
+
+### Setup Development Environment
+```bash
+git clone https://github.com/lstephensFederation/lolTasks.git
+cd lolTasks
+pip install -e .
+```
+
+### Running Tests
+```bash
+# No tests implemented yet
+```
+
+## Contributing
+
+1. Fork the repository
+2. Create a feature branch
+3. Make your changes
+4. Test thoroughly
+5. Submit a pull request
+
+## License
+
+MIT License - see LICENSE file for details.
+
+## Changelog
+
+### Version 1.0.0
+- Initial release
+- Complete task management functionality
+- Advanced text editing features
+- Cross-platform compatibility
+- Comprehensive documentation
+
+## Support
+
+For issues, questions, or contributions, please visit:
+https://github.com/lstephensFederation/lolTasks

loltasks-1.0.0/lolTasks.egg-info/SOURCES.txt

@@ -0,0 +1,11 @@
+LICENSE
+MANIFEST.in
+README.md
+setup.py
+task.py
+task_spec.md
+lolTasks.egg-info/PKG-INFO
+lolTasks.egg-info/SOURCES.txt
+lolTasks.egg-info/dependency_links.txt
+lolTasks.egg-info/entry_points.txt
+lolTasks.egg-info/top_level.txt

loltasks-1.0.0/lolTasks.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

loltasks-1.0.0/lolTasks.egg-info/entry_points.txt

@@ -0,0 +1,3 @@
+[console_scripts]
+lolTasks = task:entry_point
+task = task:entry_point

loltasks-1.0.0/lolTasks.egg-info/top_level.txt

@@ -0,0 +1 @@
+task

loltasks-1.0.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

loltasks-1.0.0/setup.py

@@ -0,0 +1,52 @@
+#!/usr/bin/env python3
+"""
+lolTasks - A terminal-based weekly task management application
+"""
+
+from setuptools import setup, find_packages
+import os
+
+# Read the README file
+this_directory = os.path.abspath(os.path.dirname(__file__))
+with open(os.path.join(this_directory, 'README.md'), encoding='utf-8') as f:
+    long_description = f.read()
+
+setup(
+    name="lolTasks",
+    version="1.0.0",
+    author="Luke J. Stephens",
+    author_email="l.stephens@federation.edu.au",
+    description="A terminal-based weekly task management application with advanced text editing",
+    long_description=long_description,
+    long_description_content_type="text/markdown",
+    url="https://github.com/lstephensFederation/lolTasks",
+    packages=find_packages(),
+    py_modules=['task'],
+    include_package_data=True,
+    license="MIT",
+    classifiers=[
+        "Development Status :: 4 - Beta",
+        "Intended Audience :: End Users/Desktop",
+        "Operating System :: OS Independent",
+        "Programming Language :: Python :: 3",
+        "Programming Language :: Python :: 3.6",
+        "Programming Language :: Python :: 3.7",
+        "Programming Language :: Python :: 3.8",
+        "Programming Language :: Python :: 3.9",
+        "Programming Language :: Python :: 3.10",
+        "Programming Language :: Python :: 3.11",
+        "Topic :: Utilities",
+    ],
+    python_requires=">=3.6",
+    entry_points={
+        'console_scripts': [
+            'lolTasks=task:entry_point',
+            'task=task:entry_point',
+        ],
+    },
+    keywords="task management terminal curses weekly planner",
+    project_urls={
+        "Bug Reports": "https://github.com/lstephensFederation/lolTasks/issues",
+        "Source": "https://github.com/lstephensFederation/lolTasks",
+    },
+)

loltasks-1.0.0/task.py

@@ -0,0 +1,575 @@
+#!/usr/bin/env python3
+import curses
+import datetime
+import json
+import os
+import sys
+from datetime import timedelta
+
+DATA_DIR = os.path.expanduser('~/.lolTasks')
+DATA_FILE = os.path.join(DATA_DIR, 'weekly_tasks.json')
+
+STATES = ['TO-DO', 'PENDING', 'COMPLETED']
+STATE_CYCLE_FORWARD = {s: STATES[(i + 1) % 3] for i, s in enumerate(STATES)}
+STATE_CYCLE_BACKWARD = {s: STATES[(i - 1) % 3] for i, s in enumerate(STATES)}
+
+# Display symbols (fixed visual width = 4 chars including spaces/brackets)
+STATE_SYMBOLS = {
+    'TO-DO':     '[ ] ',
+    'PENDING':   '[~] ',
+    'COMPLETED': '[x] ',
+}
+
+# For consistent offset calculation during editing (always 4 chars)
+PREFIX_WIDTH = 4
+
+COLORS = {'TO-DO': 1, 'PENDING': 2, 'COMPLETED': 3}
+
+def get_week_key(date):
+    y, w, _ = date.isocalendar()
+    return f"{y}-W{w:02d}"
+
+def week_to_date(year, week):
+    d = datetime.date(year, 1, 4)
+    d -= timedelta(days=d.isocalendar()[2] - 1)
+    return d + timedelta(weeks=week - 1)
+
+def load_data():
+    if os.path.exists(DATA_FILE):
+        with open(DATA_FILE, 'r') as f:
+            return json.load(f)
+    return {}
+
+def save_data(data):
+    os.makedirs(DATA_DIR, exist_ok=True)
+    with open(DATA_FILE, 'w') as f:
+        json.dump(data, f, indent=4)
+
+def get_input(stdscr, base_y, base_x, initial='', start_at_beginning=False):
+    """Safer line editor with cursor movement + vim-style start support + undo/redo + word navigation"""
+    curses.curs_set(1)
+    stdscr.keypad(True)
+    s = list(initial)
+    pos = 0 if start_at_beginning else len(s)
+
+    # Undo/redo history
+    history = [''.join(s)]
+    history_pos = 0
+
+    _, max_x = stdscr.getmaxyx()
+    display_width = max_x - base_x - 2  # margin
+
+    def save_state():
+        nonlocal history, history_pos
+        current = ''.join(s)
+        # Remove any history after current position
+        history = history[:history_pos + 1]
+        history.append(current)
+        history_pos = len(history) - 1
+        # Limit history to 50 entries
+        if len(history) > 50:
+            history.pop(0)
+            history_pos -= 1
+
+    def undo():
+        nonlocal s, pos, history_pos
+        if history_pos > 0:
+            history_pos -= 1
+            s = list(history[history_pos])
+            pos = min(pos, len(s))
+
+    def redo():
+        nonlocal s, pos, history_pos
+        if history_pos < len(history) - 1:
+            history_pos += 1
+            s = list(history[history_pos])
+            pos = min(pos, len(s))
+
+    def skip_word_left():
+        nonlocal pos
+        # Skip whitespace
+        while pos > 0 and s[pos - 1].isspace():
+            pos -= 1
+        # Skip word
+        while pos > 0 and not s[pos - 1].isspace():
+            pos -= 1
+
+    def skip_word_right():
+        nonlocal pos
+        # Skip word
+        while pos < len(s) and not s[pos].isspace():
+            pos += 1
+        # Skip whitespace
+        while pos < len(s) and s[pos].isspace():
+            pos += 1
+
+    while True:
+        start = max(0, pos - display_width + 5)
+        visible = s[start:start + display_width]
+        visible_str = ''.join(visible)
+
+        try:
+            stdscr.move(base_y, base_x)
+            stdscr.clrtoeol()
+            stdscr.addstr(base_y, base_x, visible_str)
+        except curses.error:
+            pass  # Skip if can't draw
+        try:
+            cursor_x = base_x + (pos - start)
+            stdscr.move(base_y, cursor_x)
+        except curses.error:
+            pass
+        stdscr.refresh()
+
+        key = stdscr.getkey()
+
+        if key == '\n':
+            break
+        elif key == '\x01':  # Ctrl+A - jump to start of line
+            pos = 0
+        elif key == '\x05':  # Ctrl+E - jump to end of line
+            pos = len(s)
+        elif key == '\x1b':  # Escape key or start of escape sequence
+            # Check for escape sequences
+            stdscr.nodelay(True)
+            try:
+                next_key = stdscr.getkey()
+                if next_key == 'u':  # Esc + U = undo (vim-style)
+                    undo()
+                elif next_key == 'r':  # Esc + R = redo (vim-style)
+                    redo()
+                elif next_key == 'b':  # Option + Left on macOS (\x1bb)
+                    skip_word_left()
+                elif next_key == 'f':  # Option + Right on macOS (\x1bf)
+                    skip_word_right()
+                elif next_key == '[':  # CSI sequences
+                    seq = stdscr.getkey()
+                    if seq == 'D':  # Left arrow
+                        pos = max(0, pos - 1)
+                    elif seq == 'C':  # Right arrow
+                        pos = min(len(s), pos + 1)
+                    elif seq == '1':  # \x1b[1~ (Home) or \x1b[1;9D (Option+Left)
+                        next_char = stdscr.getkey()
+                        if next_char == '~':  # \x1b[1~ - Home
+                            pos = 0
+                        elif next_char == ';':  # \x1b[1;9D - Option+Left
+                            modifier = stdscr.getkey()
+                            direction = stdscr.getkey()
+                            if modifier == '9' and direction == 'D':
+                                skip_word_left()
+                    elif seq == '4':  # \x1b[4~ (End)
+                        next_char = stdscr.getkey()
+                        if next_char == '~':
+                            pos = len(s)
+                    elif seq == '7':  # \x1b[7~ (Home on some terminals)
+                        next_char = stdscr.getkey()
+                        if next_char == '~':
+                            pos = 0
+                    elif seq == '8':  # \x1b[8~ (End on some terminals)
+                        next_char = stdscr.getkey()
+                        if next_char == '~':
+                            pos = len(s)
+                    else:
+                        # Unknown CSI sequence
+                        pass
+                else:
+                    # Single escape - exit edit mode
+                    break
+            except curses.error:
+                # Timeout or no more keys - treat as single escape
+                break
+            finally:
+                stdscr.nodelay(False)
+        elif key in ('KEY_LEFT', 'KEY_BACKSPACE', '\x7f', '\b'):
+            save_state()
+            if pos > 0:
+                pos -= 1
+                if key in ('\x7f', '\b'):
+                    del s[pos]
+        elif key == 'KEY_RIGHT':
+            if pos < len(s):
+                pos += 1
+        elif key == 'KEY_HOME':
+            pos = 0
+        elif key == 'KEY_END':
+            pos = len(s)
+        elif key == 'KEY_DC':
+            save_state()
+            if pos < len(s):
+                del s[pos]
+        elif len(key) == 1 and 32 <= ord(key) <= 126:
+            save_state()
+            s.insert(pos, key)
+            pos += 1
+
+    curses.curs_set(0)
+    return ''.join(s)
+
+def show_help():
+    print("Weekly Tasks App - task")
+    print("Keys:")
+    print("  ↑↓/kj     Move selection / Reorder (when in reorder mode)")
+    print("  r         Toggle reorder mode")
+    print("  ←→/hl     Prev/Next week")
+    print("  Tab       Cycle state forward")
+    print("  Shift+Tab Cycle state backward")
+    print("  I         Edit current item at start of line (vim-style I)")
+    print("  a         Add new task after selected")
+    print("  Enter     Edit selected item (cursor at end)")
+    print("  d         Delete selected task")
+    print("  n / p     Shift task next / prev week")
+    print("  Ctrl+U     Undo last action")
+    print("  Ctrl+R     Redo last undone action")
+    print("  q         Quit")
+    print()
+    print("In edit mode:")
+    print("  Esc       Exit edit mode")
+    print("  Esc+u     Undo (vim-style)")
+    print("  Esc+r     Redo (vim-style)")
+    print("  Option+←→ Word navigation")
+    print("  Ctrl+A/E  Line navigation (start/end)")
+    print("  Arrow keys Cursor movement")
+    sys.exit(0)
+
+def main(stdscr):
+    if len(sys.argv) > 1 and sys.argv[1] in ('--help', '-h'):
+        show_help()
+
+    curses.curs_set(0)
+    stdscr.keypad(True)
+    curses.start_color()
+    curses.init_pair(1, curses.COLOR_RED, curses.COLOR_BLACK)
+    curses.init_pair(2, curses.COLOR_BLUE, curses.COLOR_BLACK)
+    curses.init_pair(3, curses.COLOR_GREEN, curses.COLOR_BLACK)
+
+    today = datetime.date.today()
+    current_week = get_week_key(today)
+
+    active_week = current_week
+    selected = -1
+    edit_mode = False
+    reorder_mode = False
+    scroll_offset = 0
+    force_start = False
+
+    # Global undo/redo history
+    undo_history = []
+    undo_pos = -1
+    MAX_UNDO = 20
+
+    # Save initial state
+    initial_data = load_data()
+    undo_history.append(json.dumps(initial_data))
+    undo_pos = 0
+
+    def save_undo_state():
+        nonlocal undo_history, undo_pos
+        # Save current in-memory data, not from disk
+        current_data = data.copy()
+        # Remove any history after current position
+        undo_history = undo_history[:undo_pos + 1]
+        undo_history.append(json.dumps(current_data))
+        undo_pos = len(undo_history) - 1
+        # Limit history
+        if len(undo_history) > MAX_UNDO:
+            undo_history.pop(0)
+            undo_pos -= 1
+
+    def undo():
+        nonlocal undo_history, undo_pos, selected, active, prev, nxt, data
+        if undo_pos > 0:
+            undo_pos -= 1
+            restored_data = json.loads(undo_history[undo_pos])
+            save_data(restored_data)
+            # Reload data immediately
+            data = load_data()
+            active = data[active_week]
+            nxt = data[next_week]
+            prev = data[prev_week]
+            # Adjust selected index
+            selected = max(-1, min(selected, len(active['tasks']) - 1))
+            return True
+        return False
+
+    def redo():
+        nonlocal undo_history, undo_pos, selected, active, prev, nxt, data
+        if undo_pos < len(undo_history) - 1:
+            undo_pos += 1
+            restored_data = json.loads(undo_history[undo_pos])
+            save_data(restored_data)
+            # Reload data immediately
+            data = load_data()
+            active = data[active_week]
+            nxt = data[next_week]
+            prev = data[prev_week]
+            # Adjust selected index
+            selected = max(-1, min(selected, len(active['tasks']) - 1))
+            return True
+        return False
+
+    while True:
+        data = load_data()
+
+        if active_week not in data:
+            data[active_week] = {'title': 'Editable Title here for the week', 'tasks': []}
+            save_data(data)
+
+        stdscr.clear()
+        maxy, maxx = stdscr.getmaxyx()
+
+        y, w_part = active_week.split('-W')
+        y = int(y)
+        w = int(w_part)
+        active_date = week_to_date(y, w)
+        prev_date = active_date - timedelta(weeks=1)
+        next_date = active_date + timedelta(weeks=1)
+        prev_week = get_week_key(prev_date)
+        next_week = get_week_key(next_date)
+
+        for wk in [prev_week, active_week, next_week]:
+            if wk not in data:
+                data[wk] = {'title': 'Week title', 'tasks': []}
+                save_data(data)
+
+        prev = data[prev_week]
+        active = data[active_week]
+        nxt = data[next_week]
+
+        selected = max(-1, min(selected, len(active['tasks']) - 1))
+
+        # Layout positions - ensure active title is always visible
+        title_y = 0
+        prev_start_y = 2
+        prev_end_y = 6  # Previous week: title at 0, sep at 1, tasks at 2-5 (max 4 tasks)
+        active_title_y = prev_end_y + 1  # Title at line 7
+        active_start_y = active_title_y + 2  # Tasks start at line 9
+        next_start_y = maxy - 12 if maxy > 35 else active_start_y + 12
+
+        # Adjust scroll_offset to make selected visible
+        if selected >= 0:
+            visible_rows = next_start_y - active_start_y - 1
+            if selected < scroll_offset:
+                scroll_offset = selected
+            elif selected > scroll_offset + visible_rows - 1:
+                scroll_offset = selected - (visible_rows - 1)
+            scroll_offset = max(0, scroll_offset)
+
+        # Titles & separators
+        def draw_title(y, week_key, text, attr=curses.A_NORMAL):
+            if y >= maxy: return  # Skip if beyond screen
+            label = f"{week_key} – {text}"
+            if len(label) > maxx - 6:
+                label = label[:maxx-9] + "..."
+            stdscr.addstr(y, 2, label, attr)
+
+        draw_title(title_y, prev_week, prev['title'], curses.A_DIM)
+        if title_y + 1 < maxy:
+            stdscr.addstr(title_y + 1, 0, "─" * (maxx - 2), curses.A_DIM)
+
+        draw_title(active_title_y, active_week, active['title'], curses.A_BOLD)
+        if active_title_y + 1 < maxy:
+            stdscr.addstr(active_title_y + 1, 0, "═" * (maxx - 2), curses.A_BOLD)
+
+        draw_title(next_start_y - 2, next_week, nxt['title'], curses.A_DIM)
+        if next_start_y - 1 < maxy:
+            stdscr.addstr(next_start_y - 1, 0, "─" * (maxx - 2), curses.A_DIM)
+
+        # Improved tasks drawing with word-wrap for selected
+        def draw_week_tasks(base_y, week_data, is_active, sel_idx=-1, max_tasks=8, scroll_offset=0, max_y=None):
+            if max_y is None:
+                max_y = maxy
+            max_y = min(max_y, maxy - 2)  # Leave room for help bar at maxy-1
+            tasks = week_data['tasks']
+            y = base_y
+            wrap_width = maxx - 16  # margin for prefix + indent
+
+            start_idx = scroll_offset if is_active else 0
+            end_idx = len(tasks)
+            if max_tasks is not None:
+                end_idx = min(end_idx, start_idx + max_tasks)
+
+            idx = start_idx
+            while idx < end_idx and y < max_y:
+                t = tasks[idx]
+                prefix = STATE_SYMBOLS[t['state']]           # always 4 chars
+                text = t['text']
+                attr = curses.color_pair(COLORS.get(t['state'], 1))
+                if is_active and idx == sel_idx:
+                    attr |= curses.A_REVERSE
+                if not is_active:
+                    attr |= curses.A_DIM
+
+                full = prefix + text
+                if is_active and idx == sel_idx and len(full) > wrap_width:
+                    lines = []
+                    rem = full
+                    while rem:
+                        if len(rem) <= wrap_width:
+                            lines.append(rem)
+                            break
+                        split = rem.rfind(' ', 0, wrap_width)
+                        if split == -1:
+                            split = wrap_width
+                        lines.append(rem[:split])
+                        rem = rem[split:].lstrip()
+                        if rem:
+                            rem = ' ' * PREFIX_WIDTH + rem
+                    for line in lines:
+                        if y >= max_y: break
+                        try:
+                            stdscr.addstr(y, 2, line, attr)
+                        except curses.error:
+                            pass
+                        y += 1
+                else:
+                    if len(full) > wrap_width + 5:
+                        full = full[:wrap_width - 3] + "..."
+                    if y < max_y:
+                        try:
+                            stdscr.addstr(y, 2, full, attr)
+                        except curses.error:
+                            pass
+                    y += 1
+
+                idx += 1
+
+            if idx < len(tasks) and y < max_y:
+                stdscr.addstr(y, 2, "... more", curses.A_DIM)
+
+        draw_week_tasks(prev_start_y, prev, False, max_tasks=4, max_y=active_title_y - 1)
+        draw_week_tasks(active_start_y, active, True, selected, max_tasks=None, scroll_offset=scroll_offset, max_y=next_start_y - 2)
+        draw_week_tasks(next_start_y, nxt, False, max_tasks=8, max_y=maxy - 1)
+
+        # Help bar
+        mode = " [REORDER]" if reorder_mode else ""
+        hint = " (after selected)" if 0 <= selected < len(active['tasks']) else " (at end)"
+        help_txt = f"↑↓/kj:Move{'/Reorder'+mode} | r:Reorder | ←→:Week | Tab/S-Tab:State | I:Edit@start | a:Add{hint} | ⏎:Edit | d:Del | n/p:Shift | Ctrl+U:Undo | Ctrl+R:Redo | q:Quit"
+        if maxy - 1 < maxy:
+            stdscr.addstr(maxy - 1, 0, help_txt[:maxx - 1], curses.A_DIM)
+
+        stdscr.refresh()
+
+        if edit_mode:
+            if selected == -1:
+                offset = len(f"{active_week} – ")
+                new_title = get_input(stdscr, active_title_y, 2 + offset,
+                                      active['title'], start_at_beginning=force_start)
+                active['title'] = new_title
+            else:
+                t = active['tasks'][selected]
+                offset = PREFIX_WIDTH                               # ← Fixed!
+                edit_y = active_start_y + (selected - scroll_offset)
+                new_text = get_input(stdscr, edit_y, 2 + offset,
+                                     t['text'], start_at_beginning=force_start)
+                t['text'] = new_text
+            save_data(data)
+            edit_mode = False
+            force_start = False
+            continue
+
+        key = stdscr.getkey()
+        force_start = False
+
+        # Handle control key sequences
+        if key == '\x15':  # Ctrl+U = undo
+            if undo():
+                continue
+        elif key == '\x12':  # Ctrl+R = redo
+            if redo():
+                continue
+
+        # Normal mode commands
+        if key.lower() == 'q':
+            save_data(data)
+            break
+        elif key.lower() == 'r':
+            reorder_mode = not reorder_mode
+        elif key == '\t' and 0 <= selected < len(active['tasks']):
+            active['tasks'][selected]['state'] = STATE_CYCLE_FORWARD[active['tasks'][selected]['state']]
+            save_data(data)
+            save_undo_state()
+        elif key == '\x1b[Z' and 0 <= selected < len(active['tasks']):
+            active['tasks'][selected]['state'] = STATE_CYCLE_BACKWARD[active['tasks'][selected]['state']]
+            save_data(data)
+            save_undo_state()
+        elif key == 'I':  # Shift+I - edit at start
+            if selected == -1 or 0 <= selected < len(active['tasks']):
+                edit_mode = True
+                force_start = True
+        elif key in ('KEY_UP', 'k'):
+            tasks = active['tasks']
+            if reorder_mode:
+                if selected > 0:
+                    tasks[selected-1], tasks[selected] = tasks[selected], tasks[selected-1]
+                    selected -= 1
+                    save_data(data)
+                    save_undo_state()
+            else:
+                if selected > 0:
+                    selected -= 1
+                elif selected == -1 and tasks:
+                    selected = len(tasks) - 1
+        elif key in ('KEY_DOWN', 'j'):
+            tasks = active['tasks']
+            if reorder_mode:
+                if selected < len(tasks) - 1:
+                    tasks[selected+1], tasks[selected] = tasks[selected], tasks[selected+1]
+                    selected += 1
+                    save_data(data)
+                    save_undo_state()
+            else:
+                if selected == -1 and tasks:
+                    selected = 0
+                elif selected < len(tasks) - 1:
+                    selected += 1
+                elif selected == len(tasks) - 1:
+                    selected = -1
+        elif key in ('KEY_LEFT', 'h'):
+            active_week = prev_week
+            selected = -1
+            scroll_offset = 0
+        elif key in ('KEY_RIGHT', 'l'):
+            active_week = next_week
+            selected = -1
+            scroll_offset = 0
+        elif key.lower() == 'a':
+            tasks = active['tasks']
+            new_task = {'text': 'New task', 'state': 'TO-DO'}
+            if selected == -1 or selected >= len(tasks):
+                tasks.append(new_task)
+                selected = len(tasks) - 1
+            else:
+                pos = selected + 1
+                tasks.insert(pos, new_task)
+                selected = pos
+            save_data(data)
+            save_undo_state()
+            edit_mode = True
+            force_start = False
+        elif key == '\n' and selected is not None:
+            edit_mode = True
+            force_start = False
+        elif key.lower() == 'd' and 0 <= selected < len(active['tasks']):
+            del active['tasks'][selected]
+            selected = max(-1, selected - 1)
+            save_data(data)
+            save_undo_state()
+        elif key.lower() in ('n', 'p') and 0 <= selected < len(active['tasks']):
+            tasks = active['tasks']
+            task = tasks.pop(selected)
+            delta = 1 if key.lower() == 'n' else -1
+            target_date = active_date + timedelta(weeks=delta)
+            target_week = get_week_key(target_date)
+            if target_week not in data:
+                data[target_week] = {'title': 'Week title', 'tasks': []}
+            data[target_week]['tasks'].append(task)
+            selected = max(-1, min(selected, len(tasks) - 1))
+            save_data(data)
+            save_undo_state()
+
+if __name__ == '__main__':
+    curses.wrapper(main)
+
+def entry_point():
+    """Entry point for console script"""
+    curses.wrapper(main)

loltasks-1.0.0/task_spec.md

@@ -0,0 +1,247 @@
+# Weekly Tasks Application Specification
+
+## Overview
+
+The Weekly Tasks application is a terminal-based task management tool built with Python and the curses library. It provides a text-based user interface for managing weekly tasks with different completion states, allowing users to organize and track their tasks across multiple weeks.
+
+## Features
+
+### Core Functionality
+- **Weekly Task Management**: Organize tasks by ISO week (YYYY-WW format)
+- **Task States**: Three-state system (TO-DO, PENDING, COMPLETED) with visual indicators
+- **Multi-Week Navigation**: View and navigate between previous, current, and next weeks
+- **Task Operations**: Add, edit, delete, and reorder tasks
+- **State Cycling**: Change task states forward and backward
+- **Task Movement**: Move tasks between weeks
+
+### User Interface
+- **Terminal-Based**: Uses curses for full-screen text interface
+- **Color Coding**: Different colors for each task state (Red=TO-DO, Blue=PENDING, Green=COMPLETED)
+- **Responsive Layout**: Adapts to terminal size with scrollable task lists
+- **Word Wrapping**: Long task descriptions wrap properly for selected items
+- **Visual Indicators**: Checkboxes and symbols for task states
+
+## Data Model
+
+### Storage
+- **Location**: `~/.lolTasks/weekly_tasks.json`
+- **Format**: JSON file with week-based structure
+
+### Structure
+```json
+{
+  "2026-W05": {
+    "title": "Week of February 3-9, 2026",
+    "tasks": [
+      {
+        "text": "Complete project documentation",
+        "state": "TO-DO"
+      },
+      {
+        "text": "Review code changes",
+        "state": "PENDING"
+      }
+    ]
+  }
+}
+```
+
+### Task States
+- **TO-DO**: `[ ] ` - Red color, initial state
+- **PENDING**: `[~] ` - Blue color, in-progress state
+- **COMPLETED**: `[x] ` - Green color, finished state
+
+## User Interface Layout
+
+```
+Previous Week (YYYY-WW – Title)
+─────────────────────────────────
+[ ] Task 1
+[~] Task 2
+[x] Task 3
+
+Current Week (YYYY-WW – Title)
+═════════════════════════════════
+[ ] Selected task (highlighted)
+[~] Task 2
+[x] Task 3
+    ... more
+
+Next Week (YYYY-WW – Title)
+─────────────────────────────────
+[ ] Task 1
+[~] Task 2
+
+↑↓/kj:Move/Reorder | r:Reorder | ←→:Week | Tab/S-Tab:State | I:Edit@start | a:Add | ⏎:Edit | d:Del | n/p:Shift | q:Quit
+```
+
+## Key Bindings
+
+### Navigation
+- `↑/↓` or `k/j`: Move selection up/down
+- `←/→` or `h/l`: Navigate to previous/next week
+- `Tab`: Cycle task state forward (TO-DO → PENDING → COMPLETED)
+- `Shift+Tab`: Cycle task state backward
+
+### Task Management
+- `a`: Add new task after selected item
+- `Enter`: Edit selected task (or week title if none selected)
+- `I`: Edit task at beginning of line (vim-style)
+- `d`: Delete selected task
+- `r`: Toggle reorder mode for moving tasks up/down
+- `Esc`: Exit edit mode (same as Enter - saves changes)
+
+### Global Actions
+- `Ctrl + U`: Undo last action (add, delete, edit, reorder, move tasks)
+- `Ctrl + R`: Redo last undone action
+- `n`: Move task to next week
+- `p`: Move task to previous week
+- `q`: Quit application
+
+### Text Editing (when in edit mode)
+- `Esc + U`: Undo last change (vim-style)
+- `Esc + R`: Redo last undone change (vim-style)
+- `Option + Left` (macOS): Skip to previous word
+- `Option + Right` (macOS): Skip to next word
+- `Ctrl + A`: Move to start of line
+- `Ctrl + E`: Move to end of line
+- `Left/Right`: Move cursor
+- `Home/End`: Move to start/end of line
+- `Backspace/Delete`: Delete characters
+- `Enter/Esc`: Save and exit edit mode
+
+### Task Movement
+- `n`: Move task to next week
+- `p`: Move task to previous week
+
+### General
+- `q`: Quit application
+
+## File Structure
+
+```
+~/.lolTasks/
+├── task.py              # Main application script
+├── weekly_tasks.json    # Task data storage
+├── weekly_tasks.json.backup  # Backup file
+└── __pycache__/         # Python bytecode cache
+```
+
+## Dependencies
+
+### Required Python Modules
+- `curses`: Terminal user interface (built-in on Unix systems)
+- `datetime`: Date and time handling (built-in)
+- `json`: JSON data serialization (built-in)
+- `os`: Operating system interface (built-in)
+- `sys`: System-specific parameters (built-in)
+
+### System Requirements
+- Unix-like operating system (Linux, macOS)
+- Python 3.x
+- Terminal with curses support
+
+## Installation and Usage
+
+### Installation
+1. Download `task.py` to a directory in PATH
+2. Make executable: `chmod +x task.py`
+3. Run: `./task.py`
+
+### First Run
+- Application creates `~/.lolTasks/` directory automatically
+- Initializes with current week data
+- Shows help with `--help` or `-h` flag
+
+## Technical Implementation
+
+### Architecture
+- **Single File Application**: All code in `task.py`
+- **Event-Driven UI**: Main loop processes keyboard input
+- **In-Memory Data**: Loads/saves JSON data on operations
+- **State Management**: Tracks UI state (selection, modes, scroll)
+- **Global Undo/Redo**: Maintains application-level history for all operations (limited to 20 states)
+- **Edit History**: Maintains undo/redo buffer for text editing (limited to 50 entries)
+
+### Key Functions
+- `main()`: Application entry point with curses wrapper
+- `get_input()`: Safe line editing with cursor movement, undo/redo, and word navigation
+- `draw_week_tasks()`: Render tasks with wrapping and selection
+- `load_data()`/`save_data()`: JSON persistence
+- `get_week_key()`: ISO week calculation
+- `week_to_date()`: Convert week to date
+
+### Error Handling
+- Graceful handling of terminal resize
+- Safe file operations with directory creation
+- Input validation for task operations
+- Fallback for drawing operations that exceed screen bounds
+
+## Future Enhancements
+
+Potential features for future versions:
+- Task categories/tags
+- Due dates within weeks
+- Search functionality
+- Export to different formats
+- Synchronization with external services
+- Customizable color schemes
+- Keyboard shortcut customization
+
+## Lessons Learned
+
+### Undo/Redo Implementation
+
+**Critical Timing of State Saving:**
+- **Wrong approach**: Saving undo state *before* operations leads to broken redo functionality
+- **Correct approach**: Save undo state *after* operations complete and data is persisted
+- **Why**: Undo needs pre-operation state, redo needs post-operation state
+
+**Operation Sequence Matters:**
+```python
+# Incorrect (breaks redo):
+save_undo_state()  # Saves pre-operation state
+modify_data()
+save_data()
+
+# Correct (enables proper undo/redo):
+modify_data()
+save_data()
+save_undo_state()  # Saves post-operation state
+```
+
+**Data Source for State Saving:**
+- **Wrong**: Loading from disk (`load_data()`) captures stale state
+- **Correct**: Saving current in-memory data (`data.copy()`) captures actual state
+
+**UI State Management:**
+- Undo/redo operations must immediately reload all UI variables (`active`, `prev`, `nxt`)
+- Selected index must be adjusted to remain valid after state restoration
+- Avoid relying on main loop data reloading for immediate visual feedback
+
+**Debugging Complex State:**
+- Add temporary debug displays to show undo position and history length
+- Implement debug keys to test individual components
+- Use step-by-step verification: undo works → redo works → UI updates correctly
+
+### Terminal Key Binding Compatibility
+
+**Escape Sequence Parsing:**
+- **Challenge**: macOS Terminal sends complex escape sequences for modified keys
+- **Solution**: Implement comprehensive CSI sequence parsing with modifier detection
+- **Key Codes**: Handle both standard (\x1b[H/\x1b[F) and modified (\x1b[1;9D) sequences
+- **Alternative**: Use standard Unix shortcuts (Ctrl+A/Ctrl+E) for better cross-platform compatibility
+
+**Debugging Key Input:**
+- Add temporary logging to capture actual key codes sent by terminal
+- Test with different terminal applications (Terminal.app, iTerm2, etc.)
+- Verify key bindings in terminal preferences match expected codes
+- Consider standard Unix shortcuts (Ctrl+A/Ctrl+E) for better compatibility
+
+**Cross-Terminal Compatibility:**
+- Support multiple escape sequence formats for the same action
+- Handle both standard curses key codes and raw escape sequences
+- Document platform-specific key combinations in help and spec
+
+**Key Insight**: Linear undo history with position tracking works well for simple applications, but requires careful state management to avoid corruption.</content>
+<parameter name="filePath">/Users/lstephens/.lolTasks/task_spec.md