shudo 0.1.0__tar.gz

shudo-0.1.0/LICENSE.md

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Himanshu Sinha
+
+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.

shudo-0.1.0/PKG-INFO

@@ -0,0 +1,20 @@
+Metadata-Version: 2.2
+Name: shudo
+Version: 0.1.0
+Summary: ShuDo — a CLI programming productivity tool (notes, kanban tasks, pomodoro)
+License: MIT
+Keywords: productivity,notes,tasks,kanban,pomodoro,cli
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE.md
+
+# ShuDo
+
+A terminal-based programming productivity tool: **notes**, **kanban tasks**, and **pomodoro timer**.
+
+Built with Python's `curses` and SQLite.
+
+## Requirements
+
+- Python 3.8+
+- A terminal that supports curses (Linux, macOS, WSL on Windows)

shudo-0.1.0/README.md

@@ -0,0 +1,10 @@
+# ShuDo
+
+A terminal-based programming productivity tool: **notes**, **kanban tasks**, and **pomodoro timer**.
+
+Built with Python's `curses` and SQLite.
+
+## Requirements
+
+- Python 3.8+
+- A terminal that supports curses (Linux, macOS, WSL on Windows)

shudo-0.1.0/pyproject.toml

@@ -0,0 +1,19 @@
+[build-system]
+requires = ["setuptools>=64.0,<77"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "shudo"
+version = "0.1.0"
+description = "ShuDo — a CLI programming productivity tool (notes, kanban tasks, pomodoro)"
+readme = "README.md"
+requires-python = ">=3.8"
+keywords = ["productivity", "notes", "tasks", "kanban", "pomodoro", "cli"]
+license = {text = "MIT"}
+
+[project.scripts]
+shudo = "shudo.shudo:cli"
+
+[tool.setuptools.packages.find]
+include = ["shudo*"]
+

shudo-0.1.0/setup.cfg

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

shudo-0.1.0/shudo/__init__.py

@@ -0,0 +1,3 @@
+"""ShuDo — a CLI programming productivity tool."""
+
+__version__ = "0.1.0"

shudo-0.1.0/shudo/__main__.py

@@ -0,0 +1,6 @@
+"""Entry point for `python -m shudo`."""
+import curses
+from shudo.shudo import main
+
+if __name__ == "__main__":
+    curses.wrapper(main)

shudo-0.1.0/shudo/db.py

@@ -0,0 +1,270 @@
+# db.py
+import sqlite3
+import os
+import json
+
+def _get_default_db_path():
+    """Return the default database path in the user's config directory."""
+    home = os.path.expanduser("~")
+    data_dir = os.path.join(home, ".shudo")
+    os.makedirs(data_dir, exist_ok=True)
+    return os.path.join(data_dir, "shudo.db")
+
+
+class Database:
+    def __init__(self, db_path=None):
+        if db_path is None:
+            db_path = _get_default_db_path()
+        self.conn = sqlite3.connect(db_path)
+        self.conn.row_factory = sqlite3.Row
+        self.c = self.conn.cursor()
+
+    def init_db(self):
+        """Create tables if they don't exist"""
+        self.c.executescript("""
+            CREATE TABLE IF NOT EXISTS notes (
+                id INTEGER PRIMARY KEY AUTOINCREMENT,
+                title TEXT NOT NULL,
+                content TEXT NOT NULL,
+                created_at TEXT NOT NULL DEFAULT (datetime('now')),
+                updated_at TEXT NOT NULL DEFAULT (datetime('now'))
+            );
+
+            CREATE TABLE IF NOT EXISTS tasks (
+                id INTEGER PRIMARY KEY AUTOINCREMENT,
+                task TEXT NOT NULL,
+                priority TEXT NOT NULL DEFAULT 'medium'
+                    CHECK(priority IN ('high', 'medium', 'low')),
+                status TEXT NOT NULL DEFAULT 'ready'
+                    CHECK(status IN ('ready', 'ongoing', 'done')),
+                due_date TEXT,
+                subtasks TEXT NOT NULL DEFAULT '[]',
+                created_at TEXT NOT NULL DEFAULT (datetime('now')),
+                updated_at TEXT NOT NULL DEFAULT (datetime('now')),
+                archived INTEGER NOT NULL DEFAULT 0
+            );
+
+            CREATE TABLE IF NOT EXISTS pomodoros (
+                id INTEGER PRIMARY KEY AUTOINCREMENT,
+                task_id INTEGER,
+                work_minutes INTEGER NOT NULL DEFAULT 25,
+                rest_minutes INTEGER NOT NULL DEFAULT 5,
+                completed_at TEXT NOT NULL DEFAULT (datetime('now')), 
+                FOREIGN KEY (task_id) REFERENCES tasks(id)
+            );    
+
+            CREATE TABLE IF NOT EXISTS config (
+                key TEXT PRIMARY KEY,
+                value TEXT NOT NULL
+            );
+        """)
+        self.conn.commit()
+
+        # Migration: add columns if missing (for existing databases)
+        try:
+            self.c.execute("ALTER TABLE tasks ADD COLUMN updated_at TEXT NOT NULL DEFAULT (datetime('now'))")
+        except sqlite3.OperationalError:
+            pass  # column already exists
+        try:
+            self.c.execute("ALTER TABLE tasks ADD COLUMN archived INTEGER NOT NULL DEFAULT 0")
+        except sqlite3.OperationalError:
+            pass  # column already exists
+        self.conn.commit()
+    
+    def add_note(self, title, content):
+        self.c.execute("INSERT INTO notes (title, content, updated_at) VALUES (?, ?, datetime('now'))",
+                       (title, content))
+        self.conn.commit()
+        return self.c.lastrowid
+    
+    def update_note(self, note_id, title, content):
+        self.c.execute(
+            "UPDATE notes SET title = ?, content = ?, updated_at = datetime('now') WHERE id = ?",
+            (title, content, note_id))
+        self.conn.commit()
+
+    def get_notes(self):
+        self.c.execute("SELECT id, title, content, created_at, updated_at FROM notes ORDER BY updated_at DESC")
+        return self.c.fetchall()
+
+    def search_notes_by_keyword(self, keyword):
+        pattern = f"%{keyword}%"
+        self.c.execute("SELECT id, title, content, created_at, updated_at FROM notes WHERE title LIKE ? OR content LIKE ? ORDER BY updated_at DESC",
+                       (pattern, pattern))
+        return self.c.fetchall()
+
+    def delete_note(self, note_id):
+        self.c.execute("DELETE FROM notes WHERE id = ?", (note_id,))
+        self.conn.commit()
+
+    def add_task(self, task, priority="medium", due_date=None):
+        self.c.execute("INSERT INTO tasks (task, priority, status, due_date, updated_at) VALUES (?, ?, ?, ?, datetime('now'))", 
+                       (task, priority, "ready", due_date))
+        self.conn.commit()
+        return self.c.lastrowid
+    
+    def get_tasks(self, include_archived=False):
+        if include_archived:
+            self.c.execute("""
+                SELECT id, task, priority, status, due_date, subtasks, created_at, updated_at, archived
+                FROM tasks 
+                ORDER BY 
+                    CASE status 
+                        WHEN 'ready' THEN 1 
+                        WHEN 'ongoing' THEN 2 
+                        WHEN 'done' THEN 3 
+                    END,
+                    CASE priority 
+                        WHEN 'high' THEN 1 
+                        WHEN 'medium' THEN 2 
+                        WHEN 'low' THEN 3 
+                    END,
+                    due_date ASC NULLS LAST,
+                    created_at DESC
+            """)
+        else:
+            self.c.execute("""
+                SELECT id, task, priority, status, due_date, subtasks, created_at, updated_at, archived
+                FROM tasks 
+                WHERE archived = 0
+                ORDER BY 
+                    CASE status 
+                        WHEN 'ready' THEN 1 
+                        WHEN 'ongoing' THEN 2 
+                        WHEN 'done' THEN 3 
+                    END,
+                    CASE priority 
+                        WHEN 'high' THEN 1 
+                        WHEN 'medium' THEN 2 
+                        WHEN 'low' THEN 3 
+                    END,
+                    due_date ASC NULLS LAST,
+                    created_at DESC
+            """)
+        return self.c.fetchall()
+
+    def search_tasks_by_keyword(self, keyword):
+        pattern = f"%{keyword}%"
+        self.c.execute("""
+            SELECT id, task, priority, status, due_date, subtasks, created_at, updated_at, archived
+            FROM tasks
+            WHERE archived = 0
+            AND (task LIKE ? OR subtasks LIKE ?)
+            ORDER BY 
+                CASE status 
+                    WHEN 'ready' THEN 1 
+                    WHEN 'ongoing' THEN 2 
+                    WHEN 'done' THEN 3 
+                END,
+                CASE priority 
+                    WHEN 'high' THEN 1 
+                    WHEN 'medium' THEN 2 
+                    WHEN 'low' THEN 3 
+                END,
+                due_date ASC NULLS LAST,
+                created_at DESC
+        """, (pattern, pattern))
+        return self.c.fetchall()
+
+    def get_archived_tasks(self):
+        self.c.execute("""
+            SELECT id, task, priority, status, due_date, subtasks, created_at, updated_at, archived
+            FROM tasks 
+            WHERE archived = 1
+            ORDER BY updated_at DESC
+        """)
+        return self.c.fetchall()
+
+    def get_task_by_id(self, task_id):
+        self.c.execute("SELECT id, task, priority, status, due_date, subtasks, updated_at FROM tasks WHERE id = ?", (task_id,))
+        return self.c.fetchone()
+    
+    def update_task_status(self, task_id, new_status):
+        self.c.execute("UPDATE tasks SET status = ?, updated_at = datetime('now') WHERE id = ?", (new_status, task_id))
+        self.conn.commit()
+
+    def update_task(self, task_id, task_name, subtasks):
+        self.c.execute(
+            "UPDATE tasks SET task = ?, subtasks = ?, updated_at = datetime('now') WHERE id = ?",
+            (task_name, json.dumps(subtasks), task_id)
+        )
+        self.conn.commit()
+
+    def archive_task(self, task_id):
+        self.c.execute("UPDATE tasks SET archived = 1, updated_at = datetime('now') WHERE id = ?", (task_id,))
+        self.conn.commit()
+
+    def unarchive_task(self, task_id):
+        self.c.execute("UPDATE tasks SET archived = 0, updated_at = datetime('now') WHERE id = ?", (task_id,))
+        self.conn.commit()
+
+    def archive_old_done_tasks(self):
+        """Archive tasks that are done and last modified more than 1 day ago."""
+        self.c.execute("""
+            UPDATE tasks SET archived = 1, updated_at = datetime('now')
+            WHERE status = 'done'
+            AND archived = 0
+            AND updated_at < datetime('now', '-1 day')
+        """)
+        self.conn.commit()
+        return self.c.rowcount
+
+    def delete_task(self, task_id):
+        self.c.execute("DELETE FROM tasks WHERE id = ?", (task_id,))
+        self.conn.commit()
+    
+    def add_pomo_session(self, task_id, work_minutes=25, rest_minutes=5):
+        self.c.execute(
+            "INSERT INTO pomodoros (task_id, work_minutes, rest_minutes) VALUES (?, ?, ?)", 
+            (task_id, work_minutes, rest_minutes))
+        self.conn.commit()
+        return self.c.lastrowid
+
+    def get_pomo_stats(self, task_id=None):
+        if task_id is None:
+            self.c.execute("""
+                SELECT COUNT(*) as total_sessions,
+                    COALESCE(SUM(work_minutes), 0) as total_minutes
+                FROM pomodoros
+            """)
+        else:
+            self.c.execute("""
+                SELECT COUNT(*) as total_sessions,
+                    COALESCE(SUM(work_minutes), 0) as total_minutes
+                FROM pomodoros WHERE task_id = ?
+            """, (task_id,))
+        return self.c.fetchone()
+
+    def get_pomo_sessions_all(self):
+        self.c.execute("""
+            SELECT p.id, p.work_minutes, p.completed_at, t.task
+            FROM pomodoros p
+            LEFT JOIN tasks t ON p.task_id = t.id
+            ORDER BY p.completed_at DESC
+        """)
+        return self.c.fetchall()
+
+    def get_pomo_daily_avg(self):
+        """Average work minutes per day (only days with sessions)."""
+        self.c.execute("""
+            SELECT ROUND(AVG(day_total), 1) as daily_avg_minutes
+            FROM (
+                SELECT DATE(completed_at) as day, SUM(work_minutes) as day_total
+                FROM pomodoros
+                GROUP BY day
+            )
+        """)
+        row = self.c.fetchone()
+        return row["daily_avg_minutes"] if row and row["daily_avg_minutes"] else 0
+
+    def get_config(self, key, default=""):
+        self.c.execute("SELECT value FROM config WHERE key = ?", (key,))
+        row = self.c.fetchone()
+        return row["value"] if row else default
+
+    def set_config(self, key, value):
+        self.c.execute(
+            "INSERT OR REPLACE INTO config (key, value) VALUES (?, ?)",
+            (key, str(value))
+        )
+        self.conn.commit()

shudo-0.1.0/shudo/shudo.py

@@ -0,0 +1,180 @@
+#!/usr/bin/env python3
+"""ShuDo - a cli programming productivity tool"""
+
+import curses
+import time
+
+from shudo.db import Database
+from shudo.views.notes_view import NotesView
+from shudo.views.tasks_view import TasksView
+from shudo.views.pomo_view import PomoView
+
+class ShuDoApp:
+    """Main application controller."""
+
+    VIEW_NAMES = ["Notes", "Tasks", "Pomo"]
+    
+    def __init__(self, stdscr):
+        self.stdscr = stdscr
+        self.db = Database()
+        self.db.init_db()  # ensure tables exist before views query them
+        archived_count = self.db.archive_old_done_tasks()
+        if archived_count:
+            self.toast_message = f"Archived {archived_count} old done task(s)"
+            self.toast_time = time.time()
+        self.current_view = 0
+        self.running = True
+        self.command_str = "[tab] switch views  [q] quit"
+        self.toast_message = ""
+        self.toast_time = 0.0
+        self.toast_duration = 2
+
+        self.views = [
+            NotesView(self),
+            TasksView(self),
+            PomoView(self),
+        ]
+
+        curses.start_color()
+        curses.use_default_colors()
+
+        curses.init_pair(1, curses.COLOR_RED, -1)
+        curses.init_pair(2, curses.COLOR_GREEN, -1) 
+        curses.init_pair(3, curses.COLOR_YELLOW, -1)
+        curses.init_pair(4, curses.COLOR_BLUE, -1)
+        curses.init_pair(5, curses.COLOR_MAGENTA, -1)
+        curses.init_pair(6, curses.COLOR_CYAN, -1)
+        curses.init_pair(7, curses.COLOR_WHITE, -1)
+
+
+        curses.curs_set(0)
+        self.stdscr.keypad(True)
+        self.stdscr.nodelay(True)
+
+
+    @property
+    def width(self):
+        return self.stdscr.getmaxyx()[1]
+
+    @property
+    def height(self):
+        return self.stdscr.getmaxyx()[0]
+    
+    def draw_header(self):
+        h = self.stdscr
+        x = 1
+        for ch in "ShuDo | ":
+            h.addch(0, x, ch, curses.color_pair(2) | curses.A_BOLD)
+            x += 1
+        for i, name in enumerate(self.VIEW_NAMES):
+            if i == self.current_view:
+                tab = f" {name} "
+                view_colors = [3, 4, 1]  # Notes=yellow, Tasks=blue, Pomo=red
+                attr = curses.color_pair(view_colors[i]) | curses.A_BOLD
+            else:
+                tab = f" {name} "
+                attr = curses.A_DIM
+            for ch in tab:
+                if x < self.width:
+                    h.addch(0, x, ch, attr)
+                    x += 1
+        h.hline(0, x, ' ', self.width - x)
+    
+    def draw_command_string(self):
+        """Draw the last-line commands bar."""
+        y = self.height - 2
+        msg = self.command_str
+        self.stdscr.hline(y, 0, ' ', self.width)
+        if msg:
+            self.stdscr.addstr(y, 1, msg, curses.color_pair(2) | curses.A_DIM)
+    
+    def draw_toast_message(self):
+        """Draw a toast message or pomodoro mini status."""
+        y = self.height - 1
+        self.stdscr.hline(y, 0, ' ', self.width)
+
+        # check if a toast message is still active
+        if time.time() - self.toast_time <= self.toast_duration and self.toast_message:
+            self.stdscr.addstr(y, 1, self.toast_message, curses.color_pair(2))
+            return
+
+        self.toast_message = ""
+
+        # show pomodoro mini status if running in background
+        pomo = self.views[2]
+        mini = pomo.mini_status()
+        if mini:
+            self.stdscr.addstr(y, 1, mini, curses.color_pair(2))
+
+    def set_toast_message(self, message):
+        self.toast_message = message
+        self.toast_time = time.time()
+
+    def run(self):
+        while self.running:
+            # tick background timers
+            self.views[2].tick()
+
+            self.stdscr.erase()
+            self.draw_header()
+
+            self.views[self.current_view].render(
+                self.stdscr, 2, self.height - 3
+            )
+
+            self.draw_command_string()
+            self.draw_toast_message()
+            self.stdscr.refresh()
+
+            key = self.stdscr.getch()
+
+            if key == -1:
+                time.sleep(0.05)
+                continue
+            elif key == ord('q'):
+                self.running = False
+            elif key == ord('\t'):
+                self.current_view = (self.current_view + 1) % len(self.VIEW_NAMES)
+            elif key == 27: #escape
+                self.running = False
+            else:
+                self.views[self.current_view].handle_key(key)
+    
+    def prompt(self, label, default=""):
+        curses.curs_set(1)
+        self.stdscr.nodelay(False)
+
+        y = self.height - 1
+        self.stdscr.hline(y, 0, ' ', self.width)
+        self.stdscr.addstr(y, 1, label + default, curses.color_pair(2))
+
+        curses.echo()
+        result = self.stdscr.getstr(y, 1 + len(label), 60).decode("utf-8")
+        curses.noecho()
+
+        curses.curs_set(0)
+        self.stdscr.nodelay(True)
+
+        if not result and default:
+            return default
+        
+        return result.strip()
+
+def main(stdscr):
+    app = ShuDoApp(stdscr)
+    app.run()
+
+
+def cli():
+    """Entry point for the 'shudo' console script."""
+    import sys
+    # On Windows, curses may not be available
+    if sys.platform == "win32":
+        print("ShuDo requires a Unix-like terminal with curses support.")
+        print("Try using Windows Subsystem for Linux (WSL) or a terminal like Git Bash with winpty.")
+        sys.exit(1)
+    curses.wrapper(main)
+
+
+if __name__ == "__main__":
+    cli()