@jlmarcos99/todos 0.0.0-stage → 1.1.0

package/dist/app/src/sync/sync-service.js

@@ -0,0 +1,97 @@
+export class SyncService {
+    repository;
+    queue;
+    snapshot = { state: 'local-only', message: 'Local only' };
+    listeners = new Set();
+    constructor(repository, queue) {
+        this.repository = repository;
+        this.queue = queue;
+    }
+    get status() { return this.snapshot; }
+    subscribe(listener) {
+        this.listeners.add(listener);
+        listener(this.snapshot);
+        return () => this.listeners.delete(listener);
+    }
+    async linkRemote(url) {
+        this.set('syncing', 'Linking Git remote…');
+        try {
+            await this.repository.linkRemote(url);
+            this.set('synced', 'Remote linked and synchronized');
+        }
+        catch (error) {
+            this.set('error', `Could not link remote: ${safeMessage(error)}`);
+            throw error;
+        }
+    }
+    async syncBeforeRead() {
+        await this.refresh(async () => undefined);
+    }
+    async refresh(load) {
+        const hasRemote = await this.repository.hasRemote();
+        if (hasRemote)
+            this.set('syncing', 'Checking remote changes…');
+        else
+            this.set('local-only', 'Local only');
+        return this.queue.run(async () => {
+            if (hasRemote) {
+                try {
+                    await this.repository.syncBeforeRead();
+                    this.set('synced', 'Synced');
+                }
+                catch (error) {
+                    this.set('pending', `Could not pull remote changes: ${safeMessage(error)}`);
+                }
+            }
+            return load();
+        });
+    }
+    async retry() { await this.syncBeforeRead(); }
+    async commitAndPush(reason) {
+        if (!(await this.repository.hasRemote())) {
+            this.set('local-only', 'Saved locally');
+            return;
+        }
+        this.set('syncing', 'Saving and syncing…');
+        try {
+            await this.queue.run(() => this.repository.commitAndPush(reason));
+            this.set('synced', 'Synced');
+        }
+        catch (error) {
+            this.set('pending', `Saved locally; sync pending: ${safeMessage(error)}`);
+        }
+    }
+    async mutateAndSync(reason, mutation, afterSync) {
+        return this.queue.run(async () => {
+            const result = await mutation();
+            if (!(await this.repository.hasRemote())) {
+                this.set('local-only', 'Saved locally');
+                return result;
+            }
+            this.set('syncing', 'Saving and syncing…');
+            try {
+                await this.repository.commitAndPush(reason);
+                this.set('synced', 'Synced');
+            }
+            catch (error) {
+                this.set('pending', `Saved locally; sync pending: ${safeMessage(error)}`);
+            }
+            try {
+                await afterSync?.();
+            }
+            catch (error) {
+                this.set('pending', `Saved locally; refresh failed: ${safeMessage(error)}`);
+            }
+            return result;
+        });
+    }
+    async unlink() { await this.repository.unlink(); this.set('local-only', 'Remote unlinked; local history kept'); }
+    set(state, message) {
+        this.snapshot = { state, message };
+        for (const listener of this.listeners)
+            listener(this.snapshot);
+    }
+}
+function safeMessage(error) {
+    return error instanceof Error ? error.message : String(error);
+}

package/dist/app/src/tui/demo.js

@@ -0,0 +1,93 @@
+const HOUR = 60 * 60 * 1_000;
+const DAY = 24 * HOUR;
+/** Fresh data for every session. No files or repositories are modified. */
+export function createDemoVaults(now) {
+    function task(id, name, description, completedHoursAgo) {
+        const result = {
+            id,
+            name,
+            description,
+            date: new Date(now.getTime() - 3 * DAY),
+            status: completedHoursAgo !== undefined ? 'done' : 'todo',
+        };
+        if (completedHoursAgo !== undefined) {
+            result.completedAt = new Date(now.getTime() - completedHoursAgo * HOUR);
+        }
+        return result;
+    }
+    const vaults = [
+        {
+            id: 'work', name: 'Work', description: 'A clear picture of the work that matters.',
+            activity: [],
+            tasks: [
+                task('w1', 'Build the activity view', 'Keep daily progress visible, even before a task is finished.'),
+                task('w2', 'Review the authentication flow', 'Check token refresh and session expiry handling.'),
+                task('w3', 'Document the API changes', 'Write migration notes and a short usage example.'),
+                task('w4', 'Investigate the flaky build', 'Reproduce the failure and isolate the slow test.'),
+                task('w5', 'Review the pull request', 'Feedback sent and changes approved.', 2),
+                task('w6', 'Fix the pagination bug', 'The final page now returns the expected items.', 30),
+                task('w7', 'Add request validation', 'Invalid requests now return clear errors.', 72),
+            ],
+        },
+        {
+            id: 'portfolio', name: 'Portfolio', description: 'Small ideas becoming finished projects.',
+            activity: [],
+            tasks: [
+                task('p1', 'Design the Todos TUI', 'Try Vim navigation, vault switching and task states.'),
+                task('p2', 'Write the README', 'Explain the project with a small, practical example.'),
+                task('p3', 'Record a terminal demo', 'Show a short workflow across multiple vaults.'),
+                task('p4', 'Check accessibility', 'Try a narrow terminal and disable color.'),
+                task('p5', 'Define the task model', 'An initial model ready for the storage layer.', 5),
+                task('p6', 'Set up the NPM project', 'The initial project configuration is ready.', 48),
+            ],
+        },
+        {
+            id: 'personal', name: 'Personal', description: 'A little room for everything outside work.',
+            activity: [],
+            tasks: [
+                task('i1', 'Plan the week', 'Choose three priorities and make room for them.'),
+                task('i2', 'Read a chapter', 'Put the phone aside for twenty minutes.'),
+                task('i3', 'Go for a walk', 'A short break outside before finishing the day.', 50),
+            ],
+        },
+    ];
+    for (const vault of vaults) {
+        for (const task of vault.tasks) {
+            if (!task.completedAt)
+                continue;
+            vault.activity.push({
+                id: `demo-completed-${task.id}`,
+                taskId: task.id,
+                taskName: task.name,
+                date: task.completedAt,
+                kind: 'completed',
+                status: 'done',
+                note: task.description,
+            });
+        }
+        const ongoing = vault.tasks[1];
+        ongoing.status = 'in-progress';
+        const yesterday = new Date(now);
+        yesterday.setDate(yesterday.getDate() - 1);
+        yesterday.setHours(14, 30, 0, 0);
+        const today = new Date(now);
+        vault.activity.push({
+            id: `demo-yesterday-${ongoing.id}`,
+            taskId: ongoing.id,
+            taskName: ongoing.name,
+            date: yesterday,
+            kind: 'note',
+            status: 'in-progress',
+            note: 'Finished the first pass and identified a few edge cases.',
+        }, {
+            id: `demo-today-${ongoing.id}`,
+            taskId: ongoing.id,
+            taskName: ongoing.name,
+            date: today,
+            kind: 'note',
+            status: 'in-progress',
+            note: 'Working through the remaining edge cases. Next: final review.',
+        });
+    }
+    return vaults;
+}

package/dist/app/src/tui/screen.js

@@ -0,0 +1,325 @@
+import { Input, matchesKey, parseKey } from '@earendil-works/pi-tui';
+import { createDemoVaults } from "./demo.js";
+import { TodoSession } from "./session.js";
+import { theme } from "./theme.js";
+import { activityViewportHeight, dailyListLayout, dailyViewportHeight, mainColumnWidth, renderScreen, taskActivityLines } from "./view.js";
+const DOUBLE_G_TIMEOUT = 600;
+/** Connects terminal input and rendering to the application session. */
+export class TodoScreen {
+    session;
+    options;
+    input = new Input();
+    mode = 'normal';
+    showHelp = false;
+    showActivity = false;
+    activityOffset = 0;
+    dailyOffset = 0;
+    followDailySelection = true;
+    activityTaskId;
+    noteTaskId;
+    viewportWidth = 80;
+    previousGTime = 0;
+    pendingDeleteId;
+    unsubscribeSync;
+    constructor(options) {
+        this.options = options;
+        this.session = new TodoSession(options.vaults ?? createDemoVaults(options.now()), options.now, options.tasks);
+        options.tasks?.setOnReload(vaults => {
+            this.session.replaceVaults(vaults);
+            options.redraw();
+        });
+        this.unsubscribeSync = options.sync?.subscribe(snapshot => {
+            this.session.syncMessage = snapshot.message;
+            options.redraw();
+        });
+        this.input.onSubmit = value => this.submitInput(value);
+        this.input.onEscape = () => this.closeInput();
+    }
+    dispose() { this.unsubscribeSync?.(); }
+    invalidate() { }
+    handleInput(data) {
+        const command = matchesKey(data, 'shift+g') ? 'G' : matchesKey(data, 'shift+v') ? 'V' : parseKey(data) ?? data;
+        if (command !== 'g')
+            this.previousGTime = 0;
+        if (matchesKey(data, 'ctrl+c')) {
+            this.options.quit();
+            return;
+        }
+        if (this.mode !== 'normal') {
+            this.input.handleInput(data);
+        }
+        else {
+            this.handleCommand(command);
+        }
+        this.session.clampSelection();
+        this.options.redraw();
+    }
+    handleCommand(command) {
+        const confirmDelete = this.pendingDeleteId !== undefined && command === 'd'
+            && this.session.selectedTask?.id === this.pendingDeleteId;
+        if (this.pendingDeleteId !== undefined && !confirmDelete)
+            this.session.message = 'Delete cancelled.';
+        this.pendingDeleteId = undefined;
+        if (command !== 'ctrl+d' && command !== 'ctrl+u')
+            this.followDailySelection = true;
+        if (command === 'q') {
+            this.options.quit();
+            return;
+        }
+        if (command === '?' || command === 'shift+/') {
+            this.showHelp = !this.showHelp;
+            return;
+        }
+        if (this.showHelp) {
+            if (command === 'escape')
+                this.showHelp = false;
+            return;
+        }
+        if (this.showActivity) {
+            this.handleActivityCommand(command);
+            return;
+        }
+        if (confirmDelete) {
+            this.session.deleteSelectedTask();
+            return;
+        }
+        switch (command) {
+            case 'tab':
+                this.session.switchVault(1);
+                this.refreshVaults();
+                break;
+            case 'shift+tab':
+                this.session.switchVault(-1);
+                this.refreshVaults();
+                break;
+            case 'j':
+            case 'down':
+                this.session.moveSelection(1);
+                break;
+            case 'k':
+            case 'up':
+                this.session.moveSelection(-1);
+                break;
+            case 'G':
+                this.session.selected = this.session.tasks.length - 1;
+                break;
+            case 'g':
+                this.handleDoubleG();
+                break;
+            case 'h':
+            case 'left':
+                this.session.cycleView(-1);
+                break;
+            case 'l':
+            case 'right':
+                this.session.cycleView(1);
+                break;
+            case '1':
+                this.session.switchView('current');
+                break;
+            case '2':
+                this.session.switchView('daily');
+                break;
+            case '3':
+                this.session.switchView('history');
+                break;
+            case 'space':
+                this.session.toggleSelectedTask();
+                break;
+            case 's':
+                this.session.startSelectedTask();
+                break;
+            case 'n':
+                if (this.session.selectedTask)
+                    this.openInput('note');
+                break;
+            case '[':
+                this.session.changeDay(-1);
+                break;
+            case ']':
+                this.session.changeDay(1);
+                break;
+            case 't':
+                this.session.showToday();
+                break;
+            case 'ctrl+d':
+                this.scrollDailyNotes(1);
+                break;
+            case 'ctrl+u':
+                this.scrollDailyNotes(-1);
+                break;
+            case 'enter':
+                if (this.session.selectedTask) {
+                    this.showActivity = true;
+                    this.activityTaskId = this.session.selectedTask.id;
+                    this.activityOffset = 0;
+                }
+                break;
+            case 'd': {
+                const task = this.session.selectedTask;
+                if (!task)
+                    break;
+                this.pendingDeleteId = task.id;
+                this.session.message = `Delete "${task.name}"? Press d again to confirm.`;
+                break;
+            }
+            case 'a':
+                this.openInput('add');
+                break;
+            case 'V':
+                this.openInput('vault');
+                break;
+            case 'r':
+                if (this.options.sync?.status.state === 'local-only')
+                    this.openInput('link');
+                else if (this.options.refresh)
+                    this.refreshVaults();
+                else
+                    void this.options.sync?.retry();
+                break;
+            case '/':
+                this.openInput('search');
+                break;
+            case 'escape':
+                this.session.search('');
+                break;
+        }
+    }
+    handleDoubleG(goToFirst = () => { this.session.selected = 0; }) {
+        const time = Date.now();
+        if (time - this.previousGTime < DOUBLE_G_TIMEOUT) {
+            goToFirst();
+            this.previousGTime = 0;
+        }
+        else {
+            this.previousGTime = time;
+        }
+    }
+    handleActivityCommand(command) {
+        const maxOffset = this.maxActivityOffset;
+        this.activityOffset = Math.min(this.activityOffset, maxOffset);
+        switch (command) {
+            case 'escape':
+            case 'enter':
+                this.showActivity = false;
+                break;
+            case 'j':
+            case 'down':
+                this.activityOffset = Math.min(maxOffset, this.activityOffset + 1);
+                break;
+            case 'k':
+            case 'up':
+                this.activityOffset = Math.max(0, this.activityOffset - 1);
+                break;
+            case 'G':
+                this.activityOffset = maxOffset;
+                break;
+            case 'g':
+                this.handleDoubleG(() => { this.activityOffset = 0; });
+                break;
+        }
+    }
+    get maxActivityOffset() {
+        const lineCount = taskActivityLines(this.session, mainColumnWidth(this.viewportWidth), this.activityTaskId).length;
+        const visibleRows = activityViewportHeight(this.options.rows());
+        return Math.max(0, lineCount - visibleRows);
+    }
+    scrollDailyNotes(direction) {
+        if (this.session.view !== 'daily')
+            return;
+        const { lines } = dailyListLayout(this.session, mainColumnWidth(this.viewportWidth));
+        const viewportHeight = dailyViewportHeight(this.options.rows());
+        const maxOffset = Math.max(0, lines.length - viewportHeight);
+        const step = Math.max(1, Math.floor(viewportHeight / 2));
+        this.dailyOffset = Math.max(0, Math.min(maxOffset, this.dailyOffset + direction * step));
+        this.followDailySelection = false;
+    }
+    updateDailyViewport() {
+        const { lines, taskRows } = dailyListLayout(this.session, mainColumnWidth(this.viewportWidth));
+        const viewportHeight = dailyViewportHeight(this.options.rows());
+        if (this.followDailySelection) {
+            const taskStart = taskRows[this.session.selected] ?? 0;
+            const taskEnd = taskRows[this.session.selected + 1] ?? lines.length;
+            const visibleTaskEnd = taskStart + Math.min(viewportHeight, taskEnd - taskStart);
+            if (taskStart < this.dailyOffset)
+                this.dailyOffset = taskStart;
+            if (visibleTaskEnd > this.dailyOffset + viewportHeight) {
+                this.dailyOffset = visibleTaskEnd - viewportHeight;
+            }
+        }
+        const maxOffset = Math.max(0, lines.length - viewportHeight);
+        this.dailyOffset = Math.max(0, Math.min(maxOffset, this.dailyOffset));
+    }
+    openInput(mode) {
+        this.mode = mode;
+        this.noteTaskId = mode === 'note' ? this.session.selectedTask?.id : undefined;
+        this.input.setValue(mode === 'search' ? this.session.query : '');
+    }
+    submitInput(value) {
+        if (this.mode === 'add')
+            this.session.addTask(value);
+        if (this.mode === 'search')
+            this.session.search(value);
+        if (this.mode === 'note')
+            this.session.addProgressNote(value, this.noteTaskId);
+        if (this.mode === 'vault')
+            this.session.createVault(value);
+        if (this.mode === 'link')
+            this.linkRemote(value);
+        this.closeInput();
+    }
+    linkRemote(url) {
+        if (!url.trim()) {
+            this.session.syncMessage = 'Enter a Git remote URL to link this vault.';
+            return;
+        }
+        const sync = this.options.sync;
+        if (!sync)
+            return;
+        void sync.linkRemote(url).then(() => this.refreshVaults()).catch(error => {
+            this.session.syncMessage = `Could not link remote: ${error.message}`;
+            this.options.redraw();
+        });
+    }
+    refreshVaults() {
+        if (!this.options.refresh)
+            return;
+        void this.options.refresh().then(vaults => this.session.replaceVaults(vaults)).catch(error => {
+            this.session.syncMessage = `Refresh failed: ${error.message}`;
+        });
+    }
+    closeInput() {
+        this.mode = 'normal';
+        this.noteTaskId = undefined;
+        this.options.redraw();
+    }
+    render(width) {
+        this.viewportWidth = width;
+        if (this.showActivity) {
+            this.activityOffset = Math.min(this.activityOffset, this.maxActivityOffset);
+        }
+        this.session.clampSelection();
+        if (this.session.view === 'daily')
+            this.updateDailyViewport();
+        let inputLine;
+        if (this.mode !== 'normal') {
+            const labels = { add: '+ New task ', search: '/ Search ', note: '+ Progress note ' };
+            const label = this.mode === 'vault' ? '+ New vault '
+                : this.mode === 'link' ? '+ Git remote URL '
+                    : labels[this.mode];
+            // Leave room for the sidebar and the label on larger terminals.
+            const inputWidth = Math.max(1, mainColumnWidth(width) - label.length - 3);
+            inputLine = ` ${theme.accent(label)}${this.input.render(inputWidth)[0] ?? ''}`;
+        }
+        return renderScreen(this.session, {
+            width,
+            rows: this.options.rows(),
+            showHelp: this.showHelp,
+            showActivity: this.showActivity,
+            activityTaskId: this.activityTaskId,
+            activityOffset: this.activityOffset,
+            dailyOffset: this.dailyOffset,
+            inputLine,
+        });
+    }
+}

package/dist/app/src/tui/session.js

@@ -0,0 +1,167 @@
+import { getDailyItems } from "../model/daily.js";
+import { TaskService } from "../application/task-service.js";
+const DAY_IN_MILLISECONDS = 24 * 60 * 60 * 1_000;
+export const TASK_VIEWS = ['current', 'daily', 'history'];
+/** In-memory application state. It does not depend on terminal rendering. */
+export class TodoSession {
+    vaults;
+    now;
+    tasksService;
+    vaultIndex = 0;
+    view = 'current';
+    selected = 0;
+    query = '';
+    dailyDate;
+    message = 'Track what is next, what is moving, and what you have done.';
+    syncMessage = 'Local only';
+    constructor(vaults, now, tasksService = new TaskService()) {
+        this.vaults = vaults;
+        this.now = now;
+        this.tasksService = tasksService;
+        this.tasksService.setVaults(vaults);
+        this.dailyDate = new Date(now());
+    }
+    get vault() {
+        return this.vaults[this.vaultIndex];
+    }
+    get dailyItems() {
+        return getDailyItems(this.vault, this.dailyDate)
+            .filter(item => this.matchesSearch(item.name));
+    }
+    get tasks() {
+        if (this.view === 'daily')
+            return this.dailyItems.map(item => item.task);
+        return this.vault.tasks.filter(task => {
+            const matchesView = this.isInHistory(task) === (this.view === 'history');
+            return matchesView && this.matchesSearch(task.name);
+        });
+    }
+    get selectedTask() {
+        return this.tasks[this.selected];
+    }
+    matchesSearch(name) {
+        return name.toLocaleLowerCase().includes(this.query.toLocaleLowerCase());
+    }
+    isInHistory(task) {
+        if (task.status !== 'done' || !task.completedAt)
+            return false;
+        const elapsed = this.now().getTime() - task.completedAt.getTime();
+        return elapsed > DAY_IN_MILLISECONDS;
+    }
+    moveSelection(offset) {
+        this.selected += offset;
+        this.clampSelection();
+    }
+    clampSelection() {
+        const lastIndex = Math.max(0, this.tasks.length - 1);
+        this.selected = Math.max(0, Math.min(this.selected, lastIndex));
+    }
+    switchVault(direction) {
+        this.vaultIndex = (this.vaultIndex + direction + this.vaults.length) % this.vaults.length;
+        this.selected = 0;
+        this.query = '';
+        this.message = this.vault.description;
+    }
+    switchView(view) {
+        this.view = view;
+        this.selected = 0;
+    }
+    cycleView(direction) {
+        const index = TASK_VIEWS.indexOf(this.view);
+        const nextIndex = (index + direction + TASK_VIEWS.length) % TASK_VIEWS.length;
+        this.switchView(TASK_VIEWS[nextIndex]);
+    }
+    startSelectedTask() {
+        const task = this.selectedTask;
+        if (!task || task.status === 'in-progress')
+            return;
+        this.message = 'In progress. Press n to add a progress note.';
+        void this.runMutation(() => this.tasksService.startTask(this.vault, task, this.now()));
+        this.clampSelection();
+    }
+    deleteSelectedTask() {
+        const task = this.selectedTask;
+        if (!task)
+            return;
+        const name = task.name;
+        void this.runMutation(() => this.tasksService.deleteTask(this.vault, task));
+        this.message = `Deleted "${name}".`;
+        this.clampSelection();
+    }
+    toggleSelectedTask() {
+        const task = this.selectedTask;
+        if (!task)
+            return;
+        const wasDone = task.status === 'done';
+        this.message = wasDone ? 'Task reopened. Previous daily entries are preserved.' : 'Done. Recorded in today’s Daily.';
+        void this.runMutation(() => this.tasksService.toggleTask(this.vault, task, this.now()));
+        this.clampSelection();
+    }
+    addProgressNote(note, taskId = this.selectedTask?.id) {
+        const task = this.vault.tasks.find(task => task.id === taskId);
+        if (!task || !note.trim())
+            return;
+        this.message = 'Progress saved in today’s Daily.';
+        void this.runMutation(() => this.tasksService.addProgressNote(this.vault, task, note, this.now()));
+        this.clampSelection();
+    }
+    addTask(name) {
+        if (!name.trim())
+            return;
+        this.view = 'current';
+        this.query = '';
+        const operation = this.tasksService.addTask(this.vault, name, this.now());
+        this.selected = Math.max(0, this.tasks.length - 1);
+        void operation.then(task => {
+            if (task) {
+                this.selected = this.tasks.findIndex(item => item.id === task.id);
+                this.message = 'Task added.';
+            }
+        }).catch(error => { this.message = `Could not save task: ${error.message}`; });
+    }
+    search(query) {
+        this.query = query.trim();
+        this.selected = 0;
+    }
+    changeDay(offset) {
+        const date = new Date(this.dailyDate);
+        date.setDate(date.getDate() + offset);
+        this.dailyDate = date;
+        this.switchView('daily');
+    }
+    showToday() {
+        this.dailyDate = new Date(this.now());
+        this.switchView('daily');
+    }
+    replaceVaults(vaults) {
+        const previousVaultId = this.vault?.id;
+        const previousTaskId = this.selectedTask?.id;
+        this.vaults = vaults;
+        this.tasksService.setVaults(vaults);
+        const nextVault = vaults.findIndex(vault => vault.id === previousVaultId);
+        this.vaultIndex = nextVault >= 0 ? nextVault : 0;
+        const nextTask = this.tasks.findIndex(task => task.id === previousTaskId);
+        this.selected = nextTask >= 0 ? nextTask : 0;
+        this.clampSelection();
+    }
+    createVault(name) {
+        if (!name.trim())
+            return;
+        void this.tasksService.createVault(name).then(vault => {
+            if (!this.vaults.some(existing => existing.id === vault.id))
+                this.vaults.push(vault);
+            this.tasksService.setVaults(this.vaults);
+            this.vaultIndex = this.vaults.findIndex(existing => existing.id === vault.id);
+            this.selected = 0;
+            this.message = `Vault ${vault.name} created.`;
+        }).catch(error => { this.message = `Could not create vault: ${error.message}`; });
+    }
+    async runMutation(operation) {
+        try {
+            await operation();
+        }
+        catch (error) {
+            this.message = `Could not save change: ${error.message}`;
+        }
+    }
+}