@project-ava-supernova/core 0.2.71

package/dist/tasks/task-manager.js

@@ -0,0 +1,643 @@
+import { readFile, writeFile, rename, mkdir, unlink } from 'node:fs/promises';
+import { existsSync, mkdirSync, renameSync, readFileSync, writeFileSync, unlinkSync } from 'node:fs';
+import { join, basename } from 'node:path';
+import { randomUUID } from 'node:crypto';
+import { createEmptyTaskStore } from './types.js';
+import { localYmd, todayLocal } from '../core/dates.js';
+const TASKS_FILENAME = 'tasks.json';
+/**
+ * One-time move of a scoped account's global task store into a dedicated
+ * `tasks/` subfolder: `<scopedRoot>/tasks.json` → `<scopedRoot>/tasks/tasks.json`.
+ * Mirrors the `creative/` layout so the panel's "Open save folder" button has a
+ * clean target, and keeps the account root tidy. Safe to call on every startup —
+ * it no-ops once moved. Callers then construct TaskManager with
+ * `globalDir: join(scopedRoot, 'tasks')`.
+ *
+ * SYNCHRONOUS on purpose: TaskManager reads its store lazily, so the move must
+ * finish before the manager is constructed — otherwise an empty store could be
+ * written to the new path first and the move would silently skip (data loss).
+ * Call it immediately before `new TaskManager(...)`.
+ */
+export function migrateGlobalTasksToSubfolder(scopedRoot) {
+    const oldFile = join(scopedRoot, TASKS_FILENAME);
+    const newDir = join(scopedRoot, 'tasks');
+    const newFile = join(newDir, TASKS_FILENAME);
+    if (!existsSync(oldFile) || existsSync(newFile))
+        return;
+    try {
+        mkdirSync(newDir, { recursive: true });
+        try {
+            renameSync(oldFile, newFile);
+        }
+        catch {
+            // Cross-device or locked: copy then remove.
+            writeFileSync(newFile, readFileSync(oldFile, 'utf-8'), 'utf-8');
+            try {
+                unlinkSync(oldFile);
+            }
+            catch { /* leave the original */ }
+        }
+    }
+    catch {
+        /* leave the old file in place — TaskManager will still read the new dir empty */
+    }
+}
+/**
+ * The wall-clock moment a task's reminder should fire, in epoch ms — or null if
+ * the task has no reminder (no `reminderLead`, or no `dueDate` to anchor to).
+ * Date-only tasks default to a 09:00 local due time. Parsed as LOCAL time
+ * (no trailing Z) so "18:00" means 6pm where the user is.
+ * Pure + shared so the extension host and the IDE sidecar compute it identically.
+ */
+export function reminderFireTimeMs(entry) {
+    if (entry.reminderLead === undefined || !entry.dueDate)
+        return null;
+    const time = entry.dueTime && /^\d{2}:\d{2}$/.test(entry.dueTime) ? entry.dueTime : '09:00';
+    const dueMs = new Date(`${entry.dueDate}T${time}:00`).getTime();
+    if (Number.isNaN(dueMs))
+        return null;
+    return dueMs - entry.reminderLead * 60_000;
+}
+export class TaskManager {
+    globalDir;
+    projectDir;
+    projectRoot;
+    sync;
+    // In-memory caches
+    globalStore = null;
+    projectStore = null;
+    /** When true, skip all platform sync. Default: true (local-first). */
+    localOnly = true;
+    // Session tasks — in-memory only until flushed
+    sessionTasks = [];
+    constructor(opts) {
+        this.globalDir = opts.globalDir;
+        this.projectRoot = opts.projectRoot ?? null;
+        this.projectDir = opts.projectRoot ? join(opts.projectRoot, '.ava') : null;
+        this.sync = opts.sync;
+        this.localOnly = opts.localOnly ?? true;
+    }
+    /** Toggle cloud sync at runtime. */
+    setLocalOnly(value) {
+        this.localOnly = value;
+    }
+    // ── Public API — Load ──────────────────────────────────────────────────────
+    /** Load global task store. */
+    async loadGlobalStore() {
+        if (this.globalStore)
+            return this.globalStore;
+        this.globalStore = await this.loadStore(this.globalDir);
+        return this.globalStore;
+    }
+    /** Load project task store. */
+    async loadProjectStore() {
+        if (!this.projectDir)
+            return null;
+        if (this.projectStore)
+            return this.projectStore;
+        this.projectStore = await this.loadStore(this.projectDir);
+        return this.projectStore;
+    }
+    // ── Public API — CRUD ──────────────────────────────────────────────────────
+    /** Add a new task. Returns the created entry. */
+    async addTask(opts) {
+        const scope = opts.scope ?? 'project';
+        const store = scope === 'global'
+            ? await this.loadGlobalStore()
+            : await this.loadProjectStore() ?? await this.ensureProjectStore();
+        const now = new Date().toISOString();
+        const entry = {
+            id: randomUUID(),
+            title: opts.title,
+            description: opts.description,
+            priority: opts.priority ?? 'medium',
+            status: opts.status ?? 'todo',
+            dueDate: opts.dueDate,
+            dueTime: opts.dueTime,
+            // Neutral default — not everyone uses Ava to build software.
+            category: opts.category ?? 'personal',
+            source: opts.source ?? 'user',
+            project: opts.project ?? (this.projectDir ? basename(join(this.projectDir, '..')) : 'global'),
+            recurrence: opts.recurrence ?? 'none',
+            subtasks: opts.subtasks ?? [],
+            reminderLead: opts.reminderLead,
+            context: opts.context,
+            createdAt: now,
+            updatedAt: now,
+        };
+        store.entries.push(entry);
+        store.lastModified = now;
+        if (scope === 'global') {
+            this.globalStore = store;
+            await this.persistStore(this.globalDir, store);
+        }
+        else {
+            this.projectStore = store;
+            if (this.projectDir)
+                await this.persistStore(this.projectDir, store);
+        }
+        this.syncTasks(scope, store.entries);
+        return entry;
+    }
+    /** Update an existing task by ID. Searches both stores. */
+    async updateTask(id, updates) {
+        // Try global first, then project
+        let result = await this.updateInStore('global', id, updates);
+        if (!result)
+            result = await this.updateInStore('project', id, updates);
+        return result;
+    }
+    /** Delete a task by ID. Returns true if found and deleted. */
+    async deleteTask(id) {
+        const deletedGlobal = await this.deleteFromStore('global', id);
+        if (deletedGlobal)
+            return true;
+        return this.deleteFromStore('project', id);
+    }
+    /** Get a single task by ID. */
+    async getTask(id) {
+        const globalStore = await this.loadGlobalStore();
+        const found = globalStore.entries.find(e => e.id === id);
+        if (found)
+            return found;
+        const projectStore = await this.loadProjectStore();
+        return projectStore?.entries.find(e => e.id === id) ?? null;
+    }
+    /** List tasks with optional filters. Returns from both stores. */
+    async listTasks(opts) {
+        const globalStore = await this.loadGlobalStore();
+        const projectStore = await this.loadProjectStore();
+        let all = [
+            ...globalStore.entries,
+            ...(projectStore?.entries ?? []),
+        ];
+        if (opts) {
+            if (!opts.includeArchived) {
+                all = all.filter(e => e.status !== 'archived');
+            }
+            if (opts.status) {
+                const statuses = Array.isArray(opts.status) ? opts.status : [opts.status];
+                all = all.filter(e => statuses.includes(e.status));
+            }
+            if (opts.priority) {
+                all = all.filter(e => e.priority === opts.priority);
+            }
+            if (opts.category) {
+                all = all.filter(e => e.category === opts.category);
+            }
+            if (opts.source) {
+                all = all.filter(e => e.source === opts.source);
+            }
+        }
+        // Sort by priority (urgent first) then by creation date (newest first)
+        const priorityOrder = { urgent: 0, high: 1, medium: 2, low: 3 };
+        all.sort((a, b) => {
+            const pDiff = (priorityOrder[a.priority] ?? 2) - (priorityOrder[b.priority] ?? 2);
+            if (pDiff !== 0)
+                return pDiff;
+            return new Date(b.createdAt).getTime() - new Date(a.createdAt).getTime();
+        });
+        return all;
+    }
+    /** Get today's tasks — due today OR status in-progress. */
+    async getTodayTasks() {
+        // Due dates are calendar days, so 'today' must be the user's. In UTC
+        // this hid today's tasks and showed tomorrow's for anyone west of
+        // Greenwich after early evening.
+        const today = todayLocal();
+        const all = await this.listTasks();
+        return all.filter(e => e.status === 'in-progress' ||
+            (e.dueDate && e.dueDate === today && e.status !== 'done' && e.status !== 'archived'));
+    }
+    /**
+     * Reminders that are due to fire right now and haven't yet — for the
+     * host/sidecar scheduler. Skips done/archived tasks and anything already
+     * stamped (`reminderFiredAt`). Caps catch-up so a task due more than 24h ago
+     * doesn't nag on next launch.
+     */
+    async getDueReminders(nowMs = Date.now()) {
+        const all = await this.listTasks();
+        const DAY = 24 * 60 * 60_000;
+        return all.filter(e => {
+            if (e.status === 'done' || e.status === 'archived')
+                return false;
+            if (e.reminderFiredAt)
+                return false;
+            const fire = reminderFireTimeMs(e);
+            if (fire === null || nowMs < fire)
+                return false;
+            const time = e.dueTime && /^\d{2}:\d{2}$/.test(e.dueTime) ? e.dueTime : '09:00';
+            const dueMs = new Date(`${e.dueDate}T${time}:00`).getTime();
+            if (Number.isNaN(dueMs) || nowMs > dueMs + DAY)
+                return false;
+            return true;
+        });
+    }
+    /** Stamp a task's reminder as fired (dedupe guard for the scheduler). */
+    async markReminderFired(id) {
+        return this.updateTask(id, { reminderFiredAt: new Date().toISOString() });
+    }
+    /** Complete a task — sets status to 'done' and records completedAt. */
+    async completeTask(id) {
+        const entry = await this.getTask(id);
+        if (!entry)
+            return null;
+        return this.updateTask(id, { status: 'done' });
+    }
+    /** Archive a task. */
+    async archiveTask(id) {
+        return this.updateTask(id, { status: 'archived' });
+    }
+    /** Restore an archived task to todo. */
+    async restoreTask(id) {
+        return this.updateTask(id, { status: 'todo' });
+    }
+    /** Add a subtask to a task. Returns the updated task. */
+    async addSubtask(taskId, title) {
+        const entry = await this.getTask(taskId);
+        if (!entry)
+            return null;
+        const subtasks = [...entry.subtasks, { id: randomUUID(), title, done: false }];
+        return this.updateTask(taskId, { subtasks });
+    }
+    /** Toggle (or set) a subtask's done state. Returns the updated task. */
+    async toggleSubtask(taskId, subtaskId, done) {
+        const entry = await this.getTask(taskId);
+        if (!entry)
+            return null;
+        const subtasks = entry.subtasks.map(s => s.id === subtaskId ? { ...s, done: done ?? !s.done } : s);
+        return this.updateTask(taskId, { subtasks });
+    }
+    // ── Session Tasks (in-memory) ──────────────────────────────────────────────
+    /** Add a session task (in-memory only, from Ava's todo_write). */
+    addSessionTask(task) {
+        const existing = this.sessionTasks.find(t => t.id === task.id);
+        if (existing) {
+            existing.title = task.title;
+            existing.status = task.status;
+            existing.updatedAt = new Date().toISOString();
+            if (task.status === 'done' && !existing.completedAt) {
+                existing.completedAt = new Date().toISOString();
+            }
+            return;
+        }
+        const now = new Date().toISOString();
+        this.sessionTasks.push({
+            id: task.id,
+            title: task.title,
+            priority: 'medium',
+            status: task.status,
+            category: 'coding',
+            source: 'ava',
+            project: this.projectDir ? basename(join(this.projectDir, '..')) : 'global',
+            recurrence: 'none',
+            subtasks: [],
+            createdAt: now,
+            updatedAt: now,
+            completedAt: task.status === 'done' ? now : undefined,
+        });
+    }
+    /** Update a session task status. */
+    updateSessionTask(id, status) {
+        const task = this.sessionTasks.find(t => t.id === id);
+        if (task) {
+            task.status = status;
+            task.updatedAt = new Date().toISOString();
+            if (status === 'done' && !task.completedAt) {
+                task.completedAt = new Date().toISOString();
+            }
+        }
+    }
+    /** Get all session tasks. */
+    getSessionTasks() {
+        return [...this.sessionTasks];
+    }
+    /**
+     * No-op by design. Session tasks (Ava's todo_write working notes) are
+     * EPHEMERAL — they live in memory and surface only in the live "Ava's
+     * Progress" band. They are deliberately NOT persisted into the user's task
+     * store: flushing them polluted real task lists with dozens of stale `ava`
+     * todos that couldn't be cleared. The method is kept (callers across the
+     * extension, IDE, CLI and auto-executor invoke it) but does nothing.
+     */
+    async flushSessionTasks() {
+        /* intentionally empty — session todos never persist */
+    }
+    /** Clear session tasks from memory. */
+    clearSessionTasks() {
+        this.sessionTasks = [];
+    }
+    /**
+     * Hard-wipe EVERY stored task from both the global and project stores
+     * (active, done, archived alike) plus the in-memory session tasks. Empties
+     * the entry arrays directly — no per-id matching — so it clears reliably even
+     * for entries the per-id delete can't resolve (e.g. flushed `session-*` todos).
+     */
+    async clearAllStored() {
+        const globalStore = await this.loadGlobalStore();
+        globalStore.entries = [];
+        globalStore.lastModified = new Date().toISOString();
+        this.globalStore = globalStore;
+        await this.persistStore(this.globalDir, globalStore);
+        if (this.projectDir) {
+            const projectStore = (await this.loadProjectStore()) ?? (await this.ensureProjectStore());
+            projectStore.entries = [];
+            projectStore.lastModified = new Date().toISOString();
+            this.projectStore = projectStore;
+            await this.persistStore(this.projectDir, projectStore);
+        }
+        this.clearSessionTasks();
+    }
+    // ── Recurrence ─────────────────────────────────────────────────────────────
+    /** Process recurring tasks — create new instances for completed recurring tasks. */
+    async processRecurrence() {
+        const today = new Date();
+        let created = 0;
+        for (const scope of ['global', 'project']) {
+            const store = scope === 'global'
+                ? await this.loadGlobalStore()
+                : await this.loadProjectStore();
+            if (!store)
+                continue;
+            const toArchive = [];
+            const toAdd = [];
+            for (const entry of store.entries) {
+                if (entry.recurrence === 'none' || entry.status !== 'done')
+                    continue;
+                if (!entry.completedAt)
+                    continue;
+                // Calculate next due date
+                const completedDate = new Date(entry.completedAt);
+                const nextDue = new Date(completedDate);
+                switch (entry.recurrence) {
+                    case 'daily':
+                        nextDue.setDate(nextDue.getDate() + 1);
+                        break;
+                    case 'weekdays': {
+                        // Next Mon–Fri: step a day, then skip the weekend.
+                        nextDue.setDate(nextDue.getDate() + 1);
+                        const day = nextDue.getDay(); // 0 Sun … 6 Sat
+                        if (day === 6)
+                            nextDue.setDate(nextDue.getDate() + 2);
+                        else if (day === 0)
+                            nextDue.setDate(nextDue.getDate() + 1);
+                        break;
+                    }
+                    case 'monthly':
+                        nextDue.setMonth(nextDue.getMonth() + 1);
+                        break;
+                    case 'weekly':
+                    default:
+                        nextDue.setDate(nextDue.getDate() + 7);
+                        break;
+                }
+                // Cap at 7 days catchup
+                const diffDays = Math.floor((today.getTime() - nextDue.getTime()) / (1000 * 60 * 60 * 24));
+                if (diffDays > 7)
+                    continue;
+                // Only create if not already existing for this due date
+                const nextDueStr = localYmd(nextDue);
+                const alreadyExists = store.entries.some(e => e.title === entry.title && e.dueDate === nextDueStr && e.status !== 'archived');
+                if (alreadyExists)
+                    continue;
+                const now = new Date().toISOString();
+                toAdd.push({
+                    id: randomUUID(),
+                    title: entry.title,
+                    description: entry.description,
+                    priority: entry.priority,
+                    status: 'todo',
+                    dueDate: nextDueStr,
+                    dueTime: entry.dueTime,
+                    category: entry.category,
+                    source: entry.source,
+                    project: entry.project,
+                    recurrence: entry.recurrence,
+                    subtasks: entry.subtasks.map(s => ({ ...s, done: false })),
+                    reminderLead: entry.reminderLead,
+                    // Fresh instance — no reminder has fired for it yet.
+                    context: entry.context,
+                    createdAt: now,
+                    updatedAt: now,
+                });
+                toArchive.push(entry.id);
+                created++;
+            }
+            if (toAdd.length > 0 || toArchive.length > 0) {
+                for (const id of toArchive) {
+                    const entry = store.entries.find(e => e.id === id);
+                    if (entry)
+                        entry.status = 'archived';
+                }
+                store.entries.push(...toAdd);
+                store.lastModified = new Date().toISOString();
+                if (scope === 'global') {
+                    this.globalStore = store;
+                    await this.persistStore(this.globalDir, store);
+                }
+                else if (this.projectDir) {
+                    this.projectStore = store;
+                    await this.persistStore(this.projectDir, store);
+                }
+            }
+        }
+        return created;
+    }
+    // ── Private — Store I/O ────────────────────────────────────────────────────
+    async loadStore(dir) {
+        const filePath = join(dir, TASKS_FILENAME);
+        if (!existsSync(filePath))
+            return createEmptyTaskStore();
+        try {
+            const raw = await readFile(filePath, 'utf-8');
+            const data = JSON.parse(raw);
+            if ((data.version === 1 || data.version === 2) && Array.isArray(data.entries)) {
+                // Forward-migrate v1 → v2 in memory. All v2 additions are optional, so
+                // existing entries are already valid; we just bump the version stamp.
+                data.version = 2;
+                return data;
+            }
+            return createEmptyTaskStore();
+        }
+        catch {
+            return createEmptyTaskStore();
+        }
+    }
+    async persistStore(dir, store) {
+        await mkdir(dir, { recursive: true });
+        const filePath = join(dir, TASKS_FILENAME);
+        const content = JSON.stringify(store, null, 2);
+        await this.writeSafe(filePath, content);
+    }
+    async writeSafe(path, content) {
+        const { withLock } = await import('../core/file-lock.js');
+        await withLock(path, async () => {
+            const tmpPath = path + '.tmp';
+            await writeFile(tmpPath, content, 'utf-8');
+            try {
+                await rename(tmpPath, path);
+            }
+            catch (err) {
+                await unlink(tmpPath).catch(() => { });
+                throw err;
+            }
+        });
+    }
+    async ensureProjectStore() {
+        if (this.projectDir) {
+            await mkdir(this.projectDir, { recursive: true });
+        }
+        const store = createEmptyTaskStore();
+        this.projectStore = store;
+        return store;
+    }
+    async updateInStore(scope, id, updates) {
+        const store = scope === 'global'
+            ? await this.loadGlobalStore()
+            : await this.loadProjectStore();
+        if (!store)
+            return null;
+        const entry = store.entries.find(e => e.id === id);
+        if (!entry)
+            return null;
+        if (updates.title !== undefined)
+            entry.title = updates.title;
+        if (updates.description !== undefined)
+            entry.description = updates.description;
+        if (updates.priority !== undefined)
+            entry.priority = updates.priority;
+        if (updates.status !== undefined) {
+            const wasNotDone = entry.status !== 'done';
+            entry.status = updates.status;
+            if (updates.status === 'done' && wasNotDone) {
+                entry.completedAt = new Date().toISOString();
+            }
+            else if (updates.status !== 'done') {
+                entry.completedAt = undefined;
+            }
+        }
+        // Changing when a task is due re-arms its reminder (so a moved task fires
+        // again), unless the caller is explicitly stamping reminderFiredAt itself.
+        const timingChanged = (updates.dueDate !== undefined && updates.dueDate !== entry.dueDate) ||
+            (updates.dueTime !== undefined && updates.dueTime !== entry.dueTime) ||
+            (updates.reminderLead !== undefined && updates.reminderLead !== entry.reminderLead);
+        if (updates.dueDate !== undefined)
+            entry.dueDate = updates.dueDate;
+        if (updates.dueTime !== undefined)
+            entry.dueTime = updates.dueTime;
+        if (updates.category !== undefined)
+            entry.category = updates.category;
+        if (updates.recurrence !== undefined)
+            entry.recurrence = updates.recurrence;
+        if (updates.subtasks !== undefined)
+            entry.subtasks = updates.subtasks;
+        if (updates.reminderLead !== undefined)
+            entry.reminderLead = updates.reminderLead;
+        if (updates.context !== undefined)
+            entry.context = updates.context;
+        if (updates.reminderFiredAt !== undefined) {
+            entry.reminderFiredAt = updates.reminderFiredAt;
+        }
+        else if (timingChanged) {
+            entry.reminderFiredAt = undefined;
+        }
+        entry.updatedAt = new Date().toISOString();
+        store.lastModified = new Date().toISOString();
+        if (scope === 'global') {
+            this.globalStore = store;
+            await this.persistStore(this.globalDir, store);
+        }
+        else if (this.projectDir) {
+            this.projectStore = store;
+            await this.persistStore(this.projectDir, store);
+        }
+        this.syncTasks(scope, store.entries);
+        return entry;
+    }
+    async deleteFromStore(scope, id) {
+        const store = scope === 'global'
+            ? await this.loadGlobalStore()
+            : await this.loadProjectStore();
+        if (!store)
+            return false;
+        const idx = store.entries.findIndex(e => e.id === id);
+        if (idx === -1)
+            return false;
+        store.entries.splice(idx, 1);
+        store.lastModified = new Date().toISOString();
+        if (scope === 'global') {
+            this.globalStore = store;
+            await this.persistStore(this.globalDir, store);
+        }
+        else if (this.projectDir) {
+            this.projectStore = store;
+            await this.persistStore(this.projectDir, store);
+        }
+        this.syncTasks(scope, store.entries);
+        return true;
+    }
+    /** Fire-and-forget platform sync. */
+    syncTasks(_scope, entries) {
+        if (this.localOnly || !this.sync)
+            return;
+        this.sync.pushTasks(entries).catch(() => { });
+    }
+    /**
+     * Pull the latest tasks from the platform and merge into local
+     * stores. Tasks are split by their `project` field — 'global' goes
+     * to the global store; entries matching the current workspace's
+     * basename go to the project store; entries belonging to other
+     * workspaces are ignored (they'll sync when the user opens that
+     * workspace). Remote wins on newer updatedAt, consistent with push
+     * semantics. Returns the total count of new + updated tasks.
+     */
+    async pullLatest() {
+        if (!this.sync || this.localOnly)
+            return 0;
+        try {
+            const remote = await this.sync.pullTasks();
+            if (remote.length === 0)
+                return 0;
+            const globalStore = await this.loadGlobalStore();
+            const projectStore = this.projectDir ? await this.loadProjectStore() : null;
+            // Local tasks tag their `project` field with basename(projectRoot)
+            // (see construction at line ~111). Match the same shape here.
+            const projectName = this.projectRoot ? basename(this.projectRoot) : null;
+            const mergeInto = (store, r) => {
+                const existing = store.entries.find(e => e.id === r.id);
+                if (existing) {
+                    if (r.updatedAt > existing.updatedAt) {
+                        Object.assign(existing, r);
+                        return 1;
+                    }
+                    return 0;
+                }
+                store.entries.push(r);
+                return 1;
+            };
+            let updatedGlobal = 0;
+            let updatedProject = 0;
+            for (const r of remote) {
+                if (r.project === 'global') {
+                    updatedGlobal += mergeInto(globalStore, r);
+                }
+                else if (projectStore && projectName && r.project === projectName) {
+                    updatedProject += mergeInto(projectStore, r);
+                }
+            }
+            if (updatedGlobal > 0) {
+                globalStore.lastModified = new Date().toISOString();
+                await this.persistStore(this.globalDir, globalStore);
+            }
+            if (projectStore && updatedProject > 0 && this.projectDir) {
+                projectStore.lastModified = new Date().toISOString();
+                await this.persistStore(this.projectDir, projectStore);
+            }
+            return updatedGlobal + updatedProject;
+        }
+        catch {
+            return 0;
+        }
+    }
+}
+//# sourceMappingURL=task-manager.js.map