@polderlabs/openkan 0.4.0

package/dist/kanban/bulk.js

@@ -0,0 +1,139 @@
+// OpenKan — bulk batch operations across multiple tasks.
+import { join } from "path";
+import { getBoard, withWrite, renormalizeOrder, nowIso, KANBAN_DIR } from "./board.js";
+import { removeDir } from "./io.js";
+import { writeTaskMdx } from "./mdx.js";
+import { recordEvent } from "./changelog.js";
+// ─── Apply bulk ─────────────────────────────────────────────────────────────
+/**
+ * Apply a bulk operation to the board atomically.
+ *
+ * - Uses `withWrite` for a single atomic board mutation.
+ * - Writes per-task MDX for every affected task.
+ * - Records ONE `kanban.bulk` changelog event with the full diff.
+ */
+export async function applyBulk(board, operation) {
+    const applied = [];
+    const skipped = [];
+    // Collect task directories to delete AFTER withWrite (can't delete inside withWrite
+    // because the board is still referenced)
+    const toDelete = [];
+    await withWrite(async (b) => {
+        for (const taskId of operation.taskIds) {
+            const t = b.tasks.find(x => x.id === taskId);
+            if (!t) {
+                skipped.push({ taskId, kind: operation.kind, reason: "Task not found" });
+                continue;
+            }
+            const before = snapshot(t);
+            try {
+                switch (operation.kind) {
+                    case "move": {
+                        t.column = operation.column;
+                        if (typeof operation.order === "number")
+                            t.order = operation.order;
+                        break;
+                    }
+                    case "set-priority": {
+                        t.priority = operation.priority;
+                        break;
+                    }
+                    case "set-category": {
+                        t.category = operation.category;
+                        break;
+                    }
+                    case "add-tags": {
+                        t.tags = [...new Set([...t.tags, ...operation.tags])];
+                        break;
+                    }
+                    case "remove-tag": {
+                        t.tags = t.tags.filter(tag => tag !== operation.tag);
+                        break;
+                    }
+                    case "assign": {
+                        if (!t.assignees)
+                            t.assignees = [];
+                        if (!t.assignees.includes(operation.assignee)) {
+                            t.assignees = [...t.assignees, operation.assignee];
+                        }
+                        break;
+                    }
+                    case "archive": {
+                        t.archived = true;
+                        break;
+                    }
+                    case "restore": {
+                        t.archived = false;
+                        break;
+                    }
+                    case "delete": {
+                        // Capture before snapshot, then remove from board
+                        toDelete.push({ taskId, before });
+                        const idx = b.tasks.findIndex(x => x.id === taskId);
+                        if (idx !== -1)
+                            b.tasks.splice(idx, 1);
+                        break;
+                    }
+                }
+                // Skip setting updatedAt / snapshot for delete — already handled above
+                if (operation.kind !== "delete") {
+                    t.updatedAt = nowIso();
+                    const after = snapshot(t);
+                    applied.push({ taskId, kind: operation.kind, before, after });
+                }
+            }
+            catch (e) {
+                skipped.push({ taskId, kind: operation.kind, reason: String(e) });
+            }
+        }
+        // Renormalize if any move operation occurred
+        if (applied.some(a => a.kind === "move")) {
+            b.tasks = renormalizeOrder(b.tasks);
+        }
+    });
+    // Write MDX for non-delete operations
+    const boardAfter = await getBoard();
+    for (const a of applied) {
+        const t = boardAfter.tasks.find(x => x.id === a.taskId);
+        if (t) {
+            await writeTaskMdx(t, KANBAN_DIR, boardAfter);
+        }
+    }
+    // Delete task directories for delete operations
+    for (const { taskId } of toDelete) {
+        const taskDir = join(KANBAN_DIR, "tasks", taskId);
+        removeDir(taskDir);
+    }
+    // Add delete operations to applied list with before snapshot
+    for (const { taskId, before } of toDelete) {
+        applied.push({ taskId, kind: "delete", before, after: undefined });
+    }
+    const summary = {
+        moved: applied.filter(a => a.kind === "move").length,
+        tagged: applied.filter(a => ["add-tags", "remove-tag", "set-priority", "set-category", "assign"].includes(a.kind)).length,
+        archived: applied.filter(a => ["archive", "restore"].includes(a.kind)).length,
+        deleted: toDelete.length,
+        skipped: skipped.length,
+    };
+    if (applied.length > 0) {
+        recordEvent(KANBAN_DIR, "kanban.bulk", {
+            author: "user",
+            summary: `bulk ${operation.kind} on ${applied.length} task(s)`,
+            payload: { operation: operation.kind, applied, skipped },
+        });
+    }
+    return { applied, skipped, summary };
+}
+// ─── Helpers ────────────────────────────────────────────────────────────────
+function snapshot(t) {
+    return {
+        column: t.column,
+        order: t.order,
+        priority: t.priority,
+        category: t.category,
+        tags: [...t.tags],
+        assignees: [...(t.assignees ?? [])],
+        archived: t.archived,
+        state: t.state,
+    };
+}

package/dist/kanban/changelog.js

@@ -0,0 +1,186 @@
+// OpenKan — append-only JSONL changelog.
+import { readFileSync, appendFileSync, existsSync } from "node:fs";
+import { join } from "node:path";
+import { nanoid } from "nanoid";
+import { writeFileAtomic } from "./io.js";
+const CHANGELOG_FILE = "changelog.jsonl";
+function changelogPath(kanbanDir) {
+    return join(kanbanDir, CHANGELOG_FILE);
+}
+// Microsecond counter to break timestamp ties (multiple events in same ms)
+let _lastTsMs = 0;
+let _counter = 0;
+function nextCounter() {
+    const now = Date.now();
+    if (now !== _lastTsMs) {
+        _lastTsMs = now;
+        _counter = 0;
+    }
+    return _counter++;
+}
+function makeId() {
+    return `chg-${nanoid(8)}-${String(nextCounter()).padStart(3, "0")}`;
+}
+function nowIsoMicro() {
+    const ts = nextCounter();
+    // ISO with 3-digit microseconds appended to millisecond part
+    const base = new Date(_lastTsMs).toISOString().replace("Z", "");
+    return base + String(ts).padStart(3, "0") + "Z";
+}
+// ─── Write ─────────────────────────────────────────────────────────────────
+/**
+ * Append a new event to the changelog.
+ * Uses writeFileAtomic only when creating the file for the first time;
+ * thereafter uses appendFileSync so a crash mid-write cannot truncate history.
+ */
+export function recordEvent(kanbanDir, kind, partial) {
+    const event = {
+        id: makeId(),
+        ts: nowIsoMicro(),
+        kind,
+        ...partial,
+    };
+    const path = changelogPath(kanbanDir);
+    const line = JSON.stringify(event) + "\n";
+    if (!existsSync(path)) {
+        // First write — use atomic to avoid creating a truncated file
+        writeFileAtomic(path, line);
+    }
+    else {
+        // All subsequent writes — append only
+        appendFileSync(path, line, "utf-8");
+    }
+    return event;
+}
+// ─── Read ──────────────────────────────────────────────────────────────────
+/** Parse one non-empty line as JSON; warn to stderr on parse failure. */
+function parseLine(line) {
+    const trimmed = line.trim();
+    if (!trimmed)
+        return null;
+    try {
+        return JSON.parse(trimmed);
+    }
+    catch {
+        console.warn(`[changelog] Skipping unparseable line: ${trimmed.slice(0, 120)}`);
+        return null;
+    }
+}
+/** Kinds that represent terminal / completion events — used for completedOnly filter */
+export const COMPLETION_KINDS = new Set([
+    "task.deleted",
+    "task.archived",
+    "task.restored",
+    "kanban.organized",
+    "git.commit-attributed",
+    "agent.ended",
+    "settings.changed",
+]);
+export function readEvents(kanbanDir, opts) {
+    const path = changelogPath(kanbanDir);
+    if (!existsSync(path))
+        return { events: [], total: 0 };
+    let raw;
+    try {
+        raw = readFileSync(path, "utf-8");
+    }
+    catch {
+        return { events: [], total: 0 };
+    }
+    const all = [];
+    for (const line of raw.split("\n")) {
+        const event = parseLine(line);
+        if (event)
+            all.push(event);
+    }
+    // Filter in-memory; changelog is small enough for v1
+    const kinds = opts?.kind
+        ? (Array.isArray(opts.kind) ? opts.kind : [opts.kind])
+        : null;
+    const filtered = all.filter(e => {
+        if (opts?.since && e.ts < opts.since)
+            return false;
+        if (opts?.until && e.ts > opts.until)
+            return false;
+        if (kinds && !kinds.includes(e.kind))
+            return false;
+        if (opts?.taskId && e.taskId !== opts.taskId)
+            return false;
+        if (opts?.author && e.author !== opts.author)
+            return false;
+        return true;
+    });
+    // Newest first
+    filtered.sort((a, b) => b.ts.localeCompare(a.ts));
+    // completedOnly post-filter: only show events for tasks in "done" column, or terminal kinds
+    let finalEvents = filtered;
+    if (opts?.completedOnly) {
+        // Load done-column task IDs from board.json (sync, using already-imported readFileSync)
+        const doneTaskIds = new Set();
+        if (opts?.kanbanDirForCompletedOnly) {
+            try {
+                const boardPath = join(opts.kanbanDirForCompletedOnly, "board.json");
+                if (existsSync(boardPath)) {
+                    const board = JSON.parse(readFileSync(boardPath, "utf-8"));
+                    for (const t of board.tasks) {
+                        if (t.column === "done")
+                            doneTaskIds.add(t.id);
+                    }
+                }
+            }
+            catch { /* ignore */ }
+        }
+        finalEvents = filtered.filter(e => {
+            // Always include terminal kinds
+            if (COMPLETION_KINDS.has(e.kind))
+                return true;
+            // Include events whose task is currently in done column
+            if (e.taskId && doneTaskIds.has(e.taskId))
+                return true;
+            return false;
+        });
+    }
+    const total = finalEvents.length;
+    const offset = opts?.reset ? 0 : (opts?.offset ?? 0);
+    const limit = opts?.limit ?? 200;
+    const events = finalEvents.slice(offset, offset + limit);
+    return { events, total };
+}
+export function readEventById(kanbanDir, id) {
+    const path = changelogPath(kanbanDir);
+    if (!existsSync(path))
+        return null;
+    let raw;
+    try {
+        raw = readFileSync(path, "utf-8");
+    }
+    catch {
+        return null;
+    }
+    for (const line of raw.split("\n")) {
+        const event = parseLine(line);
+        if (event && event.id === id)
+            return event;
+    }
+    return null;
+}
+// ─── Summary ────────────────────────────────────────────────────────────────
+export function readSummary(kanbanDir, opts) {
+    const path = changelogPath(kanbanDir);
+    const since = opts?.days
+        ? new Date(Date.now() - opts.days * 24 * 60 * 60 * 1000).toISOString()
+        : undefined;
+    const { events } = readEvents(kanbanDir, { since });
+    const byKind = {};
+    const byAuthor = {};
+    const byDay = {}; // YYYY-MM-DD in local time
+    for (const e of events) {
+        byKind[e.kind] = (byKind[e.kind] ?? 0) + 1;
+        byAuthor[e.author] = (byAuthor[e.author] ?? 0) + 1;
+        // Local date (not UTC) — uses the host timezone
+        const d = new Date(e.ts);
+        const local = d.toLocaleDateString("en-CA"); // YYYY-MM-DD in local timezone
+        byDay[local] = (byDay[local] ?? 0) + 1;
+    }
+    return { byKind, byAuthor, byDay, total: events.length };
+}