taskify-nostr 0.1.0

package/dist/shared/dateUtils.js

@@ -0,0 +1,123 @@
+// Minimal date utilities for taskify-cli (no browser dependencies)
+export function startOfDay(d) {
+    const result = new Date(d);
+    result.setHours(0, 0, 0, 0);
+    return result;
+}
+export function isoDatePart(iso, tz) {
+    if (!iso)
+        return "";
+    try {
+        if (tz) {
+            const date = new Date(iso);
+            if (Number.isNaN(date.getTime()))
+                return iso.slice(0, 10);
+            const parts = new Intl.DateTimeFormat("en-CA", {
+                timeZone: tz,
+                year: "numeric",
+                month: "2-digit",
+                day: "2-digit",
+            }).formatToParts(date);
+            const year = parts.find((p) => p.type === "year")?.value ?? "";
+            const month = parts.find((p) => p.type === "month")?.value ?? "";
+            const day = parts.find((p) => p.type === "day")?.value ?? "";
+            return `${year}-${month}-${day}`;
+        }
+    }
+    catch {
+        // fall through
+    }
+    return iso.slice(0, 10);
+}
+export function isoTimePart(iso, tz) {
+    if (!iso)
+        return "";
+    try {
+        if (tz) {
+            const date = new Date(iso);
+            if (Number.isNaN(date.getTime()))
+                return "";
+            const parts = new Intl.DateTimeFormat("en-GB", {
+                timeZone: tz,
+                hour: "2-digit",
+                minute: "2-digit",
+                hour12: false,
+            }).formatToParts(date);
+            const hour = parts.find((p) => p.type === "hour")?.value ?? "";
+            const minute = parts.find((p) => p.type === "minute")?.value ?? "";
+            return `${hour}:${minute}`;
+        }
+    }
+    catch {
+        // fall through
+    }
+    // UTC fallback
+    const d = new Date(iso);
+    if (Number.isNaN(d.getTime()))
+        return "";
+    const h = String(d.getUTCHours()).padStart(2, "0");
+    const m = String(d.getUTCMinutes()).padStart(2, "0");
+    return `${h}:${m}`;
+}
+export function isoTimePartUtc(iso) {
+    const d = new Date(iso);
+    if (Number.isNaN(d.getTime()))
+        return "";
+    const h = String(d.getUTCHours()).padStart(2, "0");
+    const m = String(d.getUTCMinutes()).padStart(2, "0");
+    return `${h}:${m}`;
+}
+export function parseDateKey(key) {
+    const match = /^(\d{4})-(\d{2})-(\d{2})$/.exec(key);
+    if (!match)
+        return null;
+    return {
+        year: Number(match[1]),
+        month: Number(match[2]),
+        day: Number(match[3]),
+    };
+}
+export function formatDateKeyFromParts(year, month, day) {
+    return `${String(year).padStart(4, "0")}-${String(month).padStart(2, "0")}-${String(day).padStart(2, "0")}`;
+}
+export function isoFromDateTime(dateKey, time, tz) {
+    if (!time) {
+        return new Date(`${dateKey}T00:00:00Z`).toISOString();
+    }
+    if (tz) {
+        try {
+            // Build a date string and convert from the given timezone
+            const localStr = `${dateKey}T${time}:00`;
+            const date = new Date(new Intl.DateTimeFormat("en-CA", {
+                timeZone: tz,
+                year: "numeric",
+                month: "2-digit",
+                day: "2-digit",
+                hour: "2-digit",
+                minute: "2-digit",
+                second: "2-digit",
+                hour12: false,
+            }).format(new Date(localStr)));
+            if (!Number.isNaN(date.getTime()))
+                return date.toISOString();
+        }
+        catch {
+            // fall through
+        }
+    }
+    return new Date(`${dateKey}T${time}:00Z`).toISOString();
+}
+export function normalizeTimeZone(tz) {
+    if (!tz || typeof tz !== "string")
+        return null;
+    const trimmed = tz.trim();
+    if (!trimmed)
+        return null;
+    try {
+        Intl.DateTimeFormat(undefined, { timeZone: trimmed });
+        return trimmed;
+    }
+    catch {
+        return null;
+    }
+}

package/dist/shared/nostr.js

@@ -0,0 +1,70 @@
+import { bytesToHex, hexToBytes } from "@noble/hashes/utils";
+import { getPublicKey, nip19 } from "nostr-tools";
+function arrayLikeToHex(data) {
+    return Array.from(data).map((x) => x.toString(16).padStart(2, "0")).join("");
+}
+/**
+ * Normalize Nostr public key input into a compressed 33-byte hex string (66 chars).
+ */
+export function normalizeNostrPubkey(input) {
+    let value = input?.trim();
+    if (!value)
+        return null;
+    if (/^nostr:/i.test(value)) {
+        value = value.replace(/^nostr:/i, "");
+    }
+    const lowerValue = value.toLowerCase();
+    const maybeHex = lowerValue.startsWith("0x") ? lowerValue.slice(2) : lowerValue;
+    if (/^(02|03)[0-9a-f]{64}$/.test(maybeHex)) {
+        return maybeHex;
+    }
+    if (/^[0-9a-f]{64}$/.test(maybeHex)) {
+        return `02${maybeHex}`;
+    }
+    try {
+        const decoded = nip19.decode(lowerValue);
+        if (decoded.type !== "npub" || !decoded.data)
+            return null;
+        const decodedData = decoded.data;
+        if (typeof decodedData === "string") {
+            if (/^[0-9a-f]{64}$/.test(decodedData))
+                return `02${decodedData.toLowerCase()}`;
+            return null;
+        }
+        if (decodedData instanceof Uint8Array) {
+            return `02${bytesToHex(decodedData).toLowerCase()}`;
+        }
+        if (Array.isArray(decodedData)) {
+            return `02${arrayLikeToHex(decodedData).toLowerCase()}`;
+        }
+    }
+    catch {
+        // fall through to null
+    }
+    return null;
+}
+export function toNpub(input) {
+    const normalized = normalizeNostrPubkey(input);
+    if (!normalized)
+        return null;
+    try {
+        return nip19.npubEncode(normalized.slice(-64));
+    }
+    catch {
+        return null;
+    }
+}
+export function isValidNostrPubkeyHex(value) {
+    return typeof value === "string" && /^(02|03)[0-9a-fA-F]{64}$/.test(value);
+}
+export function deriveCompressedPubkeyFromSecret(secretHex) {
+    if (!/^[0-9a-fA-F]{64}$/.test(secretHex?.trim() || ""))
+        return null;
+    try {
+        const pubkey = getPublicKey(hexToBytes(secretHex.trim()));
+        return `02${pubkey.toLowerCase()}`;
+    }
+    catch {
+        return null;
+    }
+}

package/dist/shared/settingsTypes.js

@@ -0,0 +1,23 @@
+// CLI-adapted version of settingsTypes.ts (browser imports removed)
+export const ACCENT_CHOICES = [
+    {
+        id: "blue",
+        label: "iMessage blue",
+        fill: "#0a84ff",
+        ring: "rgba(64, 156, 255, 0.32)",
+        border: "rgba(64, 156, 255, 0.38)",
+        borderActive: "rgba(64, 156, 255, 0.88)",
+        shadow: "0 12px 26px rgba(10, 132, 255, 0.32)",
+        shadowActive: "0 18px 34px rgba(10, 132, 255, 0.42)",
+    },
+    {
+        id: "green",
+        label: "Mint green",
+        fill: "#34c759",
+        ring: "rgba(52, 199, 89, 0.28)",
+        border: "rgba(52, 199, 89, 0.36)",
+        borderActive: "rgba(52, 199, 89, 0.86)",
+        shadow: "0 12px 24px rgba(52, 199, 89, 0.28)",
+        shadowActive: "0 18px 32px rgba(52, 199, 89, 0.38)",
+    },
+];

package/dist/shared/taskTypes.js

@@ -0,0 +1,12 @@
+// CLI-adapted version of taskTypes.ts (browser imports removed)
+export const TASK_PRIORITY_MARKS = {
+    1: "!",
+    2: "!!",
+    3: "!!!",
+};
+export function isExternalCalendarEvent(event) {
+    return event.external === true;
+}
+export function isListLikeBoard(board) {
+    return !!board && (board.kind === "lists" || board.kind === "compound");
+}

package/dist/shared/taskUtils.js

@@ -0,0 +1,261 @@
+import { isoDatePart, isoTimePartUtc, startOfDay } from "./dateUtils.js";
+import { revealsOnDueDate, isFrequentRecurrence } from "./boardUtils.js";
+// ---- Priority normalization ----
+export function normalizeTaskPriority(value) {
+    if (typeof value === "number" && Number.isFinite(value)) {
+        const rounded = Math.round(value);
+        if (rounded === 1 || rounded === 2 || rounded === 3)
+            return rounded;
+    }
+    if (typeof value === "string") {
+        const trimmed = value.trim();
+        if (trimmed === "!" || trimmed === "!!" || trimmed === "!!!") {
+            return trimmed.length;
+        }
+        const parsed = Number.parseInt(trimmed, 10);
+        if (parsed === 1 || parsed === 2 || parsed === 3)
+            return parsed;
+    }
+    return undefined;
+}
+const DEFAULT_BOARD_SORT_DIRECTION = {
+    manual: "asc",
+    due: "asc",
+    priority: "desc",
+    created: "desc",
+    alpha: "asc",
+};
+const BOARD_SORT_MODE_IDS = new Set(["manual", "due", "priority", "created", "alpha"]);
+export function normalizeBoardSortState(value) {
+    const modeRaw = typeof value?.mode === "string" ? value.mode : "";
+    if (!BOARD_SORT_MODE_IDS.has(modeRaw))
+        return null;
+    const mode = modeRaw;
+    const directionRaw = typeof value?.direction === "string" ? value.direction : "";
+    const direction = directionRaw === "asc" || directionRaw === "desc" ? directionRaw : DEFAULT_BOARD_SORT_DIRECTION[mode];
+    return { mode, direction };
+}
+// ---- Bounty list helpers ----
+export function taskHasBountyList(task, key) {
+    if (!key)
+        return false;
+    if (!Array.isArray(task.bountyLists))
+        return false;
+    return task.bountyLists.includes(key);
+}
+export function withTaskAddedToBountyList(task, key) {
+    if (!key)
+        return task;
+    if (taskHasBountyList(task, key))
+        return task;
+    const nextLists = Array.isArray(task.bountyLists) ? [...task.bountyLists, key] : [key];
+    return { ...task, bountyLists: nextLists };
+}
+export function withTaskRemovedFromBountyList(task, key) {
+    if (!key || !Array.isArray(task.bountyLists))
+        return task;
+    if (!task.bountyLists.includes(key))
+        return task;
+    const filtered = task.bountyLists.filter((value) => value !== key);
+    if (filtered.length === 0) {
+        const clone = { ...task };
+        delete clone.bountyLists;
+        return clone;
+    }
+    return { ...task, bountyLists: filtered };
+}
+export function isRecoverableBountyTask(task) {
+    return !!task.bounty && typeof task.bountyDeletedAt === "string" && task.bountyDeletedAt.trim().length > 0;
+}
+// ---- Nostr pubkey helpers ----
+export function toXOnlyHex(value) {
+    if (typeof value !== "string")
+        return null;
+    const trimmed = value.trim().toLowerCase();
+    const hex = trimmed.startsWith("0x") ? trimmed.slice(2) : trimmed;
+    if (/^(02|03)[0-9a-f]{64}$/.test(hex)) {
+        return hex.slice(-64);
+    }
+    if (/^[0-9a-f]{64}$/.test(hex)) {
+        return hex;
+    }
+    return null;
+}
+export function ensureXOnlyHex(value) {
+    const normalized = toXOnlyHex(value);
+    return normalized ?? undefined;
+}
+export function pubkeysEqual(a, b) {
+    const ax = toXOnlyHex(a);
+    const bx = toXOnlyHex(b);
+    return !!(ax && bx && ax === bx);
+}
+// ---- Bounty normalization ----
+export function normalizeBounty(bounty) {
+    if (!bounty)
+        return undefined;
+    const normalized = { ...bounty };
+    const owner = ensureXOnlyHex(normalized.owner);
+    if (owner)
+        normalized.owner = owner;
+    else
+        delete normalized.owner;
+    const sender = ensureXOnlyHex(normalized.sender);
+    if (sender)
+        normalized.sender = sender;
+    else
+        delete normalized.sender;
+    const receiver = ensureXOnlyHex(normalized.receiver);
+    if (receiver)
+        normalized.receiver = receiver;
+    else
+        delete normalized.receiver;
+    const token = typeof normalized.token === "string" ? normalized.token : "";
+    const hasToken = token.trim().length > 0;
+    const hasCipher = normalized.enc !== undefined && normalized.enc !== null;
+    if (normalized.state === "claimed" || normalized.state === "revoked") {
+        return normalized;
+    }
+    if (hasToken && !hasCipher) {
+        normalized.state = "unlocked";
+        if (!normalized.lock || normalized.lock === "unknown") {
+            normalized.lock = "none";
+        }
+    }
+    else if (hasCipher && !hasToken) {
+        normalized.state = "locked";
+    }
+    else if (hasToken && hasCipher) {
+        normalized.state = "unlocked";
+    }
+    else {
+        normalized.state = "locked";
+    }
+    return normalized;
+}
+export function normalizeTaskBounty(task) {
+    if (!Object.prototype.hasOwnProperty.call(task, "bounty")) {
+        return task;
+    }
+    const clone = { ...task };
+    const bounty = clone.bounty;
+    if (!bounty) {
+        delete clone.bounty;
+        return clone;
+    }
+    const normalized = normalizeBounty(bounty);
+    if (!normalized) {
+        delete clone.bounty;
+        return clone;
+    }
+    clone.bounty = normalized;
+    return clone;
+}
+// ---- Bounty state label ----
+export function bountyStateLabel(bounty) {
+    return bounty.state;
+}
+// ---- Streak helpers ----
+export function mergeLongestStreak(task, streak) {
+    const previous = typeof task.longestStreak === "number"
+        ? task.longestStreak
+        : typeof task.streak === "number"
+            ? task.streak
+            : undefined;
+    if (typeof streak === "number") {
+        return previous === undefined ? streak : Math.max(previous, streak);
+    }
+    return previous;
+}
+// ---- Recurrence normalization ----
+export function normalizeHiddenForRecurring(task) {
+    if (!task.hiddenUntilISO || !task.recurrence || !revealsOnDueDate(task.recurrence)) {
+        return task;
+    }
+    const dueMidnight = startOfDay(new Date(task.dueISO));
+    const hiddenMidnight = startOfDay(new Date(task.hiddenUntilISO));
+    if (Number.isNaN(dueMidnight.getTime()) || Number.isNaN(hiddenMidnight.getTime()))
+        return task;
+    const today = startOfDay(new Date());
+    if (dueMidnight.getTime() > today.getTime() && hiddenMidnight.getTime() < dueMidnight.getTime()) {
+        return { ...task, hiddenUntilISO: dueMidnight.toISOString() };
+    }
+    return task;
+}
+export function recurrenceSeriesKey(task) {
+    if (!task.recurrence)
+        return null;
+    if (task.seriesId)
+        return `series:${task.boardId}:${task.seriesId}`;
+    const recurrence = JSON.stringify(task.recurrence);
+    return `sig:${task.boardId}::${task.title}::${task.note || ""}::${recurrence}`;
+}
+export function recurringInstanceId(seriesId, dueISO, rule, timeZone) {
+    const datePart = isoDatePart(dueISO, timeZone);
+    const timePart = rule && rule.type === "every" && rule.unit === "hour"
+        ? isoTimePartUtc(dueISO)
+        : "";
+    const suffix = timePart ? `${datePart}T${timePart}` : datePart;
+    return `recurrence:${seriesId}:${suffix}`;
+}
+export function recurringOccurrenceKey(task) {
+    if (!task.recurrence || !isFrequentRecurrence(task.recurrence))
+        return null;
+    const seriesKey = recurrenceSeriesKey(task);
+    if (!seriesKey)
+        return null;
+    const datePart = isoDatePart(task.dueISO, task.dueTimeZone);
+    return `${seriesKey}::${datePart}`;
+}
+export function pickRecurringDuplicate(a, b) {
+    const aCompleted = !!a.completed;
+    const bCompleted = !!b.completed;
+    if (aCompleted !== bCompleted)
+        return aCompleted ? a : b;
+    const aCompletedAt = a.completedAt ? Date.parse(a.completedAt) : 0;
+    const bCompletedAt = b.completedAt ? Date.parse(b.completedAt) : 0;
+    if (aCompletedAt !== bCompletedAt)
+        return aCompletedAt >= bCompletedAt ? a : b;
+    const aIsBase = !!(a.seriesId && a.id === a.seriesId);
+    const bIsBase = !!(b.seriesId && b.id === b.seriesId);
+    if (aIsBase !== bIsBase)
+        return aIsBase ? a : b;
+    const aOrder = typeof a.order === "number" ? a.order : Number.POSITIVE_INFINITY;
+    const bOrder = typeof b.order === "number" ? b.order : Number.POSITIVE_INFINITY;
+    if (aOrder !== bOrder)
+        return aOrder < bOrder ? a : b;
+    return a.id.localeCompare(b.id) <= 0 ? a : b;
+}
+export function dedupeRecurringInstances(tasks) {
+    const out = [];
+    const indexByKey = new Map();
+    let changed = false;
+    for (const task of tasks) {
+        const key = recurringOccurrenceKey(task);
+        if (!key) {
+            out.push(task);
+            continue;
+        }
+        const existingIndex = indexByKey.get(key);
+        if (existingIndex === undefined) {
+            indexByKey.set(key, out.length);
+            out.push(task);
+            continue;
+        }
+        const existing = out[existingIndex];
+        const winner = pickRecurringDuplicate(existing, task);
+        if (winner !== existing) {
+            out[existingIndex] = winner;
+        }
+        changed = true;
+    }
+    return changed ? out : tasks;
+}
+// ---- Task created-at normalization ----
+export function normalizeTaskCreatedAt(value) {
+    if (typeof value === "number" && Number.isFinite(value))
+        return value;
+    return undefined;
+}
+// ---- Bounty list key ----
+export const PINNED_BOUNTY_LIST_KEY = "taskify::pinned";

package/dist/taskCache.js

@@ -0,0 +1,59 @@
+// Task cache for fast completions and repeated list calls.
+// Cache file: ~/.config/taskify/cache.json
+import { readFileSync, writeFileSync, unlinkSync, mkdirSync } from "fs";
+import { join } from "path";
+import { homedir } from "os";
+export const CACHE_DIR = join(homedir(), ".config", "taskify");
+export const CACHE_PATH = join(CACHE_DIR, "cache.json");
+export const CACHE_TTL_MS = 300_000; // 5 minutes
+export function readCache() {
+    try {
+        const raw = readFileSync(CACHE_PATH, "utf-8");
+        return JSON.parse(raw);
+    }
+    catch {
+        return { boards: {} };
+    }
+}
+export function writeCache(cache) {
+    try {
+        mkdirSync(CACHE_DIR, { recursive: true });
+        writeFileSync(CACHE_PATH, JSON.stringify(cache, null, 2), "utf-8");
+    }
+    catch {
+        // Non-fatal: cache writes are best-effort
+    }
+}
+export function clearCache() {
+    try {
+        unlinkSync(CACHE_PATH);
+    }
+    catch {
+        // Non-fatal if already missing
+    }
+}
+export function isCacheFresh(boardCache) {
+    return Date.now() - boardCache.fetchedAt < CACHE_TTL_MS;
+}
+/** Read open task IDs from cache synchronously for shell completions. */
+export function readCachedOpenTaskIds() {
+    try {
+        const raw = readFileSync(CACHE_PATH, "utf-8");
+        const cache = JSON.parse(raw);
+        const now = Date.now();
+        const results = [];
+        for (const boardCache of Object.values(cache.boards ?? {})) {
+            if (now - boardCache.fetchedAt > CACHE_TTL_MS)
+                continue;
+            for (const task of boardCache.tasks ?? []) {
+                if (task.status === "open") {
+                    results.push({ id: task.id.slice(0, 8), title: task.title });
+                }
+            }
+        }
+        return results;
+    }
+    catch {
+        return [];
+    }
+}

package/package.json

@@ -0,0 +1,44 @@
+{
+  "name": "taskify-nostr",
+  "version": "0.1.0",
+  "description": "Nostr-powered task management CLI",
+  "type": "module",
+  "bin": {
+    "taskify": "./dist/index.js"
+  },
+  "scripts": {
+    "build": "tsc && node -e \"const fs=require('fs');const f='dist/index.js';let c=fs.readFileSync(f,'utf8');if(c.startsWith('#!'))c=c.slice(c.indexOf('\\n')+1);fs.writeFileSync(f,'#!/usr/bin/env node\\n'+c)\"",
+    "prepare": "npm run build",
+    "start": "node dist/index.js",
+    "dev": "node --experimental-strip-types src/index.ts"
+  },
+  "files": [
+    "dist/",
+    "README.md"
+  ],
+  "engines": {
+    "node": ">=22.0.0"
+  },
+  "keywords": [
+    "nostr",
+    "tasks",
+    "cli",
+    "productivity"
+  ],
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/Solife-me/Taskify_Release"
+  },
+  "dependencies": {
+    "@noble/hashes": "^1.4.0",
+    "@nostr-dev-kit/ndk": "^2.18.1",
+    "chalk": "^5.3.0",
+    "commander": "^12.0.0",
+    "nostr-tools": "^2.16.2"
+  },
+  "devDependencies": {
+    "@types/node": "^25.4.0",
+    "typescript": "^5.9.3"
+  }
+}