ente-cli 0.1.0

package/dist/commands/task.js

@@ -0,0 +1,305 @@
+import { resolveEntity, resolveEntities, resolveSpaceByName } from "../resolve.js";
+import { parseDeadline, defaultDeadline } from "../deadline.js";
+import { formatTaskList, formatTaskDetail, formatSpacesFooter, jsonOutputWithSpaces, } from "../format.js";
+import { parseAttrs } from "../utils.js";
+const TZ = "Europe/Berlin";
+function endOfTodayBerlin() {
+    const berlinStr = new Date().toLocaleDateString("en-CA", { timeZone: TZ });
+    const [y, m, d] = berlinStr.split("-").map(Number);
+    const pad = (n) => String(n).padStart(2, "0");
+    const naive = `${y}-${pad(m)}-${pad(d)}T23:59:59`;
+    const utcGuess = new Date(`${naive}Z`);
+    const formatter = new Intl.DateTimeFormat("en-US", {
+        timeZone: TZ,
+        hour: "2-digit",
+        minute: "2-digit",
+        hour12: false,
+    });
+    const parts = formatter.formatToParts(utcGuess);
+    const berlinHour = Number(parts.find((p) => p.type === "hour")?.value ?? 0);
+    const berlinMinute = Number(parts.find((p) => p.type === "minute")?.value ?? 0);
+    let offsetMinutes = (berlinHour * 60 + berlinMinute) - (utcGuess.getUTCHours() * 60 + utcGuess.getUTCMinutes());
+    if (offsetMinutes > 720)
+        offsetMinutes -= 1440;
+    if (offsetMinutes < -720)
+        offsetMinutes += 1440;
+    return utcGuess.getTime() - offsetMinutes * 60000;
+}
+export function registerTaskCommands(program, getClient) {
+    const task = program.command("task").description("Manage tasks");
+    // -- list -----------------------------------------------------------------
+    task
+        .command("list")
+        .description("List open tasks")
+        .option("--due <filter>", "Filter: today, overdue, all")
+        .option("--entity <name>", "Filter by entity (name or ID)")
+        .option("--json", "Output raw JSON")
+        .action(async (opts) => {
+        const client = getClient();
+        const query = {
+            onlyOpen: true,
+        };
+        if (opts.entity) {
+            query.entityId = await resolveEntity(client, opts.entity);
+        }
+        if (opts.due === "all") {
+            query.onlyOpen = false;
+        }
+        else if (opts.due === "today") {
+            query.dueBy = endOfTodayBerlin();
+        }
+        else if (opts.due === "overdue") {
+            query.dueBy = Date.now();
+        }
+        else if (opts.due) {
+            console.error(`Unknown --due value: '${opts.due}'. Use: today, overdue, or all.`);
+            process.exit(1);
+        }
+        const [res, spaces] = await Promise.all([
+            client.listTasks(query),
+            client.listSpaces(),
+        ]);
+        // Sort by deadline ascending (earliest first)
+        res.data.sort((a, b) => {
+            const da = a.activity.deadline ?? Infinity;
+            const db = b.activity.deadline ?? Infinity;
+            return da - db;
+        });
+        if (opts.json) {
+            console.log(jsonOutputWithSpaces(res, spaces));
+        }
+        else {
+            console.log(formatTaskList(res.data, res.users));
+            console.log(formatSpacesFooter(spaces));
+        }
+    });
+    // -- get ------------------------------------------------------------------
+    task
+        .command("get <id>")
+        .description("Get task by shortId (#N) or activity ID")
+        .option("--space <name-or-id>", "Filter by space (name or ID) to disambiguate shortIds")
+        .option("--json", "Output raw JSON")
+        .action(async (id, opts) => {
+        const client = getClient();
+        let spaceId;
+        if (opts.space) {
+            spaceId = await resolveSpaceByName(client, opts.space);
+        }
+        const [res, spaces] = await Promise.all([
+            getTask(client, id, spaceId),
+            client.listSpaces(),
+        ]);
+        if (opts.json) {
+            console.log(jsonOutputWithSpaces(res, spaces));
+        }
+        else {
+            console.log(formatTaskDetail(res.data, res.users));
+            console.log(formatSpacesFooter(spaces));
+        }
+    });
+    // -- create ---------------------------------------------------------------
+    task
+        .command("create <title>")
+        .description("Create a task")
+        .requiredOption("--entity <names...>", "Linked entities (resolved by name)")
+        .requiredOption("--space <name-or-id>", "Space to create the task in (name or ID). Determines who can see this task.")
+        .option("--deadline <when>", "Deadline (human-friendly)")
+        .option("--attr <pairs...>", "Attributes as key=value pairs")
+        .option("--content <text>", "Task content/description")
+        .option("--assignee <userIds...>", "Assignee user IDs")
+        .option("--auto-link", "Auto-link entities not yet in the target space (only works for personal space)")
+        .option("--json", "Output raw JSON")
+        .addHelpText("after", `
+Examples:
+  ente task create "Reply to Ashley" --entity "Ashley" --entity "TiVA" --space "Personal" --auto-link --deadline "tomorrow"
+  ente task create "Fix bug" --entity "TiVA" --space "TiVA" --deadline "+3 days" --attr github-issue=https://...
+  ente task create "Call Erik" --entity "Erik Stahl" --entity "Preclinics" --space "Preclinics" --deadline "today 14:00"
+
+--space determines who can see the activity (required):
+  - Use your personal space for private notes, reflections, personal tasks.
+  - Use a shared space (e.g. "Preclinics", "TiVA") for business activities visible to colleagues.
+  All linked entities must belong to the target space. If an entity doesn't belong yet,
+  use --auto-link to add it (only works when --space is your personal space).
+
+Deadlines: "tomorrow", "today", "+3 days", "+1 week", "2026-03-15", "2026-03-15 14:00"
+Default deadline: tomorrow 22:00 Berlin. Default time when only date given: 22:00.
+Always link ALL relevant entities (person + their org + project if applicable).`)
+        .action(async (title, opts) => {
+        const client = getClient();
+        const entityIds = await resolveEntities(client, opts.entity);
+        const spaceId = await resolveSpaceByName(client, opts.space);
+        const deadline = opts.deadline
+            ? parseDeadline(opts.deadline)
+            : defaultDeadline();
+        const attributes = parseAttrs(opts.attr);
+        const res = await client.createActivity({
+            entityIds,
+            type: "task",
+            title,
+            content: opts.content,
+            deadline,
+            spaceId,
+            attributes: Object.keys(attributes).length > 0 ? attributes : undefined,
+            assigneeIds: opts.assignee,
+            autoLinkPersonalSpace: opts.autoLink ?? false,
+        });
+        const spaces = await client.listSpaces();
+        if (opts.json) {
+            console.log(jsonOutputWithSpaces(res, spaces));
+        }
+        else {
+            console.log(`Created task '${title}' (${res.data.activityId})`);
+            console.log(formatSpacesFooter(spaces));
+        }
+    });
+    // -- update ---------------------------------------------------------------
+    task
+        .command("update <id>")
+        .description("Update a task")
+        .option("--title <text>", "Update title")
+        .option("--content <text>", "Update content")
+        .option("--attr <pairs...>", "Set attributes as key=value pairs")
+        .option("--deadline <when>", "Update deadline (human-friendly)")
+        .option("--json", "Output raw JSON")
+        .action(async (id, opts) => {
+        const client = getClient();
+        const activityId = await resolveTaskId(client, id);
+        const body = {};
+        if (opts.title !== undefined)
+            body.title = opts.title;
+        if (opts.content !== undefined)
+            body.content = opts.content;
+        if (opts.deadline)
+            body.deadline = parseDeadline(opts.deadline);
+        const attributes = parseAttrs(opts.attr);
+        if (Object.keys(attributes).length > 0)
+            body.attributes = attributes;
+        if (Object.keys(body).length === 0) {
+            console.error("Nothing to update. Specify --title, --content, --attr, or --deadline.");
+            process.exit(1);
+        }
+        const [res, spaces] = await Promise.all([
+            client.updateActivity(activityId, body),
+            client.listSpaces(),
+        ]);
+        if (opts.json) {
+            console.log(jsonOutputWithSpaces(res, spaces));
+        }
+        else {
+            console.log(`Updated task ${id}`);
+            console.log(formatSpacesFooter(spaces));
+        }
+    });
+    // -- done -----------------------------------------------------------------
+    task
+        .command("done <id>")
+        .description("Mark task as completed")
+        .option("--json", "Output JSON")
+        .action(async (id, opts) => {
+        const client = getClient();
+        const activityId = await resolveTaskId(client, id);
+        const [, spaces] = await Promise.all([
+            client.updateActivity(activityId, { completed: true }),
+            client.listSpaces(),
+        ]);
+        if (opts.json) {
+            console.log(jsonOutputWithSpaces({ data: { success: true, activityId } }, spaces));
+        }
+        else {
+            console.log(`Task ${id} marked as done.`);
+            console.log(formatSpacesFooter(spaces));
+        }
+    });
+    // -- assign / unassign ----------------------------------------------------
+    task
+        .command("assign <id> <userId>")
+        .description("Add assignee to task")
+        .option("--json", "Output JSON")
+        .action(async (id, userId, opts) => {
+        const client = getClient();
+        const taskRes = await getTask(client, id);
+        const activityId = taskRes.data.activity._id;
+        const current = taskRes.data.activity.assigneeIds || [];
+        if (current.includes(userId)) {
+            console.log("User is already assigned.");
+            return;
+        }
+        const [, spaces] = await Promise.all([
+            client.updateActivity(activityId, { assigneeIds: [...current, userId] }),
+            client.listSpaces(),
+        ]);
+        if (opts.json) {
+            console.log(jsonOutputWithSpaces({ data: { success: true, activityId, assigneeIds: [...current, userId] } }, spaces));
+        }
+        else {
+            console.log(`Assigned ${userId} to task ${id}.`);
+            console.log(formatSpacesFooter(spaces));
+        }
+    });
+    task
+        .command("unassign <id> <userId>")
+        .description("Remove assignee from task")
+        .option("--json", "Output JSON")
+        .action(async (id, userId, opts) => {
+        const client = getClient();
+        const taskRes = await getTask(client, id);
+        const activityId = taskRes.data.activity._id;
+        const current = taskRes.data.activity.assigneeIds || [];
+        if (!current.includes(userId)) {
+            console.log("User is not assigned to this task.");
+            return;
+        }
+        const updated = current.filter((u) => u !== userId);
+        const [, spaces] = await Promise.all([
+            client.updateActivity(activityId, { assigneeIds: updated }),
+            client.listSpaces(),
+        ]);
+        if (opts.json) {
+            console.log(jsonOutputWithSpaces({ data: { success: true, activityId, assigneeIds: updated } }, spaces));
+        }
+        else {
+            console.log(`Unassigned ${userId} from task ${id}.`);
+            console.log(formatSpacesFooter(spaces));
+        }
+    });
+}
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+async function getTask(client, id, spaceId) {
+    const num = parseShortId(id);
+    if (num !== null) {
+        return client.getTaskByNumber(num, spaceId ? { spaceId } : undefined);
+    }
+    // Fallback: treat as activity ID — search open tasks first, then all
+    const openTasks = await client.listTasks({ onlyOpen: true });
+    let match = openTasks.data.find((t) => t.activity._id === id);
+    let users = openTasks.users ?? {};
+    if (!match) {
+        // Also check completed tasks
+        const allTasks = await client.listTasks({ onlyOpen: false });
+        match = allTasks.data.find((t) => t.activity._id === id);
+        users = allTasks.users ?? {};
+    }
+    if (!match) {
+        throw new Error(`No task found with ID "${id}". Use short ID (#N) for easier lookup.`);
+    }
+    return { data: match, users };
+}
+async function resolveTaskId(client, id) {
+    const num = parseShortId(id);
+    if (num !== null) {
+        const res = await client.getTaskByNumber(num);
+        return res.data.activity._id;
+    }
+    // Assume it's a raw activity ID
+    return id;
+}
+function parseShortId(id) {
+    const cleaned = id.startsWith("#") ? id.slice(1) : id;
+    const n = parseInt(cleaned, 10);
+    if (!isNaN(n) && String(n) === cleaned)
+        return n;
+    return null;
+}
+//# sourceMappingURL=task.js.map

package/dist/commands/update.d.ts

@@ -0,0 +1,7 @@
+import { Command } from "commander";
+/**
+ * Check for updates (non-blocking, cached for 24h).
+ * Call at CLI startup — prints a hint if outdated.
+ */
+export declare function checkForUpdates(): Promise<void>;
+export declare function registerUpdate(program: Command): void;

package/dist/commands/update.js

@@ -0,0 +1,104 @@
+import * as fs from "fs";
+import * as path from "path";
+import * as os from "os";
+import { execSync } from "child_process";
+const PACKAGE_NAME = "ente-cli";
+const CACHE_DIR = path.join(os.homedir(), ".config", "ente");
+const VERSION_CACHE = path.join(CACHE_DIR, ".version-check.json");
+const CHECK_INTERVAL_MS = 24 * 60 * 60 * 1000; // 24 hours
+function readCache() {
+    try {
+        const raw = fs.readFileSync(VERSION_CACHE, "utf-8");
+        return JSON.parse(raw);
+    }
+    catch {
+        return null;
+    }
+}
+function writeCache(cache) {
+    fs.mkdirSync(CACHE_DIR, { recursive: true });
+    fs.writeFileSync(VERSION_CACHE, JSON.stringify(cache));
+}
+async function fetchLatestVersion() {
+    try {
+        const res = await fetch(`https://registry.npmjs.org/${PACKAGE_NAME}/latest`, {
+            signal: AbortSignal.timeout(3000), // 3s timeout — don't block CLI
+        });
+        if (!res.ok)
+            return null;
+        const data = await res.json();
+        return data.version || null;
+    }
+    catch {
+        return null;
+    }
+}
+function getCurrentVersion() {
+    // Read from package.json at build time (embedded in dist)
+    try {
+        const pkgPath = path.join(path.dirname(new URL(import.meta.url).pathname), "..", "package.json");
+        const pkg = JSON.parse(fs.readFileSync(pkgPath, "utf-8"));
+        return pkg.version;
+    }
+    catch {
+        return "0.0.0";
+    }
+}
+function compareVersions(a, b) {
+    const pa = a.split(".").map(Number);
+    const pb = b.split(".").map(Number);
+    for (let i = 0; i < 3; i++) {
+        if ((pa[i] || 0) < (pb[i] || 0))
+            return -1;
+        if ((pa[i] || 0) > (pb[i] || 0))
+            return 1;
+    }
+    return 0;
+}
+/**
+ * Check for updates (non-blocking, cached for 24h).
+ * Call at CLI startup — prints a hint if outdated.
+ */
+export async function checkForUpdates() {
+    const current = getCurrentVersion();
+    const cache = readCache();
+    let latest;
+    if (cache && Date.now() - cache.checkedAt < CHECK_INTERVAL_MS) {
+        latest = cache.latest;
+    }
+    else {
+        const fetched = await fetchLatestVersion();
+        if (!fetched)
+            return; // network issue, skip silently
+        latest = fetched;
+        writeCache({ latest, checkedAt: Date.now() });
+    }
+    if (compareVersions(current, latest) < 0) {
+        console.error(`\n⚠ ente-cli v${current} → v${latest} available. Run: ente update\n`);
+    }
+}
+export function registerUpdate(program) {
+    program
+        .command("update")
+        .description("Update ente-cli to the latest version")
+        .action(() => {
+        const current = getCurrentVersion();
+        console.log(`Current version: ${current}`);
+        console.log(`Updating ${PACKAGE_NAME}...`);
+        try {
+            // Detect how the CLI was installed
+            const npmGlobalPrefix = execSync("npm prefix -g", { encoding: "utf-8" }).trim();
+            execSync(`npm install -g ${PACKAGE_NAME}@latest`, {
+                stdio: "inherit",
+            });
+            console.log("✓ Updated successfully");
+        }
+        catch {
+            // Fallback: try npx
+            console.error("npm global install failed. Try manually:");
+            console.error(`  npm install -g ${PACKAGE_NAME}@latest`);
+            process.exit(1);
+        }
+    });
+}
+//# sourceMappingURL=update.js.map

package/dist/deadline.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Human-friendly deadline parsing. All times in Europe/Berlin.
+ */
+export declare function parseDeadline(input: string): number;
+/** Default deadline: tomorrow 22:00 Berlin */
+export declare function defaultDeadline(): number;

package/dist/deadline.js

@@ -0,0 +1,171 @@
+/**
+ * Human-friendly deadline parsing. All times in Europe/Berlin.
+ */
+const TZ = "Europe/Berlin";
+const DEFAULT_HOUR = 22;
+const DEFAULT_MINUTE = 0;
+/** Get current date components in Berlin timezone */
+function berlinNowParts() {
+    const formatter = new Intl.DateTimeFormat("en-CA", {
+        timeZone: TZ,
+        year: "numeric",
+        month: "2-digit",
+        day: "2-digit",
+    });
+    const s = formatter.format(new Date()); // "YYYY-MM-DD"
+    const [y, m, d] = s.split("-").map(Number);
+    return { year: y, month: m, day: d };
+}
+/**
+ * Convert a Berlin date+time to epoch milliseconds.
+ * Uses a two-pass approach to handle DST correctly.
+ */
+function berlinDate(year, month, day, hour, minute) {
+    const pad = (n) => String(n).padStart(2, "0");
+    const naive = `${year}-${pad(month)}-${pad(day)}T${pad(hour)}:${pad(minute)}:00`;
+    // Start with the naive time interpreted as UTC
+    const utcGuess = new Date(`${naive}Z`);
+    // Find what Berlin hour this UTC time corresponds to
+    const formatter = new Intl.DateTimeFormat("en-US", {
+        timeZone: TZ,
+        hour: "2-digit",
+        minute: "2-digit",
+        hour12: false,
+    });
+    const parts = formatter.formatToParts(utcGuess);
+    const berlinHour = Number(parts.find((p) => p.type === "hour")?.value ?? 0);
+    const berlinMinute = Number(parts.find((p) => p.type === "minute")?.value ?? 0);
+    // Compute offset in minutes (handles midnight crossing correctly)
+    let offsetMinutes = (berlinHour * 60 + berlinMinute) - (utcGuess.getUTCHours() * 60 + utcGuess.getUTCMinutes());
+    // Normalize to [-720, 720] (±12 hours)
+    if (offsetMinutes > 720)
+        offsetMinutes -= 1440;
+    if (offsetMinutes < -720)
+        offsetMinutes += 1440;
+    // Target UTC = naive time minus offset
+    const targetUtc = new Date(utcGuess.getTime() - offsetMinutes * 60000);
+    // Verify with a second pass (handles DST transitions)
+    const checkParts = formatter.formatToParts(targetUtc);
+    const checkHour = Number(checkParts.find((p) => p.type === "hour")?.value ?? 0);
+    if (checkHour !== hour) {
+        const correction = (hour - checkHour + 24) % 24;
+        // Only correct by ±1 hour for DST
+        if (correction === 1 || correction === 23) {
+            targetUtc.setTime(targetUtc.getTime() + (correction === 1 ? 3600000 : -3600000));
+        }
+    }
+    return targetUtc.getTime();
+}
+function parseTime(s) {
+    const m = s.match(/^(\d{1,2}):(\d{2})$/);
+    if (!m)
+        return null;
+    const hour = parseInt(m[1], 10);
+    const minute = parseInt(m[2], 10);
+    if (hour < 0 || hour > 23 || minute < 0 || minute > 59)
+        return null;
+    return { hour, minute };
+}
+export function parseDeadline(input) {
+    const trimmed = input.trim().toLowerCase();
+    const now = berlinNowParts();
+    // "tomorrow" or "tomorrow 14:00"
+    if (trimmed.startsWith("tomorrow")) {
+        const rest = trimmed.slice("tomorrow".length).trim();
+        let hour = DEFAULT_HOUR;
+        let minute = DEFAULT_MINUTE;
+        if (rest) {
+            const timeParts = parseTime(rest);
+            if (!timeParts) {
+                throw new Error(`Invalid time format: '${rest}'. Use HH:MM (e.g. 14:00).`);
+            }
+            hour = timeParts.hour;
+            minute = timeParts.minute;
+        }
+        const d = new Date(now.year, now.month - 1, now.day + 1);
+        return berlinDate(d.getFullYear(), d.getMonth() + 1, d.getDate(), hour, minute);
+    }
+    // "today" or "today 14:00"
+    if (trimmed.startsWith("today")) {
+        const rest = trimmed.slice("today".length).trim();
+        let hour = DEFAULT_HOUR;
+        let minute = DEFAULT_MINUTE;
+        if (rest) {
+            const timeParts = parseTime(rest);
+            if (!timeParts) {
+                throw new Error(`Invalid time format: '${rest}'. Use HH:MM (e.g. 14:00).`);
+            }
+            hour = timeParts.hour;
+            minute = timeParts.minute;
+        }
+        return berlinDate(now.year, now.month, now.day, hour, minute);
+    }
+    // "+3 days", "+1 week", "+2 weeks"
+    const relMatch = trimmed.match(/^\+(\d+)\s*(day|days|week|weeks)$/);
+    if (relMatch) {
+        const n = parseInt(relMatch[1], 10);
+        const unit = relMatch[2];
+        const days = unit.startsWith("week") ? n * 7 : n;
+        const d = new Date(now.year, now.month - 1, now.day + days);
+        return berlinDate(d.getFullYear(), d.getMonth() + 1, d.getDate(), DEFAULT_HOUR, DEFAULT_MINUTE);
+    }
+    // ISO 8601 with timezone offset: "2026-03-28T22:00:00+01:00", "2026-03-28T22:00:00Z"
+    const isoMatch = trimmed.match(/^(\d{4})-(\d{2})-(\d{2})t(\d{2}):(\d{2})(?::(\d{2}))?(?:z|([+-])(\d{2}):(\d{2}))$/);
+    if (isoMatch) {
+        const year = parseInt(isoMatch[1], 10);
+        const month = parseInt(isoMatch[2], 10);
+        const day = parseInt(isoMatch[3], 10);
+        const hour = parseInt(isoMatch[4], 10);
+        const minute = parseInt(isoMatch[5], 10);
+        const second = isoMatch[6] ? parseInt(isoMatch[6], 10) : 0;
+        if (month < 1 || month > 12 || day < 1 || day > 31) {
+            throw new Error(`Invalid date: '${input}'.`);
+        }
+        if (hour > 23 || minute > 59 || second > 59) {
+            throw new Error(`Invalid time in deadline: '${input}'.`);
+        }
+        // Validate date exists
+        const testDate = new Date(year, month - 1, day);
+        if (testDate.getFullYear() !== year || testDate.getMonth() !== month - 1 || testDate.getDate() !== day) {
+            throw new Error(`Invalid date: '${input}' — day ${day} does not exist in month ${month}.`);
+        }
+        // If 'Z' matched, offset is 0; otherwise parse sign/hours/minutes
+        const offsetSign = isoMatch[7] === "-" ? -1 : 1;
+        const offsetHours = isoMatch[8] ? parseInt(isoMatch[8], 10) : 0;
+        const offsetMinutes = isoMatch[9] ? parseInt(isoMatch[9], 10) : 0;
+        const totalOffsetMs = offsetSign * (offsetHours * 60 + offsetMinutes) * 60000;
+        // Compute UTC directly from the given offset
+        const utcMs = Date.UTC(year, month - 1, day, hour, minute, second) - totalOffsetMs;
+        return utcMs;
+    }
+    // "2026-03-15" or "2026-03-15 14:00"
+    const dateMatch = trimmed.match(/^(\d{4})-(\d{2})-(\d{2})(?:\s+(\d{1,2}):(\d{2}))?$/);
+    if (dateMatch) {
+        const year = parseInt(dateMatch[1], 10);
+        const month = parseInt(dateMatch[2], 10);
+        const day = parseInt(dateMatch[3], 10);
+        if (month < 1 || month > 12 || day < 1 || day > 31) {
+            throw new Error(`Invalid date: '${input}'.`);
+        }
+        // Validate the date actually exists (e.g. reject Feb 30)
+        const testDate = new Date(year, month - 1, day);
+        if (testDate.getFullYear() !== year || testDate.getMonth() !== month - 1 || testDate.getDate() !== day) {
+            throw new Error(`Invalid date: '${input}' — day ${day} does not exist in month ${month}.`);
+        }
+        const hour = dateMatch[4] ? parseInt(dateMatch[4], 10) : DEFAULT_HOUR;
+        const minute = dateMatch[5] ? parseInt(dateMatch[5], 10) : DEFAULT_MINUTE;
+        if (hour < 0 || hour > 23 || minute < 0 || minute > 59) {
+            throw new Error(`Invalid time in deadline: '${input}'.`);
+        }
+        return berlinDate(year, month, day, hour, minute);
+    }
+    throw new Error(`Cannot parse deadline '${input}'. ` +
+        `Accepted: "tomorrow", "today", "+3 days", "+1 week", "2026-03-15", "2026-03-15 14:00", "2026-03-15T14:00:00+01:00"`);
+}
+/** Default deadline: tomorrow 22:00 Berlin */
+export function defaultDeadline() {
+    const now = berlinNowParts();
+    const d = new Date(now.year, now.month - 1, now.day + 1);
+    return berlinDate(d.getFullYear(), d.getMonth() + 1, d.getDate(), DEFAULT_HOUR, DEFAULT_MINUTE);
+}
+//# sourceMappingURL=deadline.js.map

package/dist/format.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Human-readable output formatting.
+ */
+import type { Activity, EntityResult, OpenTaskSummary, SpaceInfo, Pin, TaskResult, UserInfo } from "./api.js";
+export declare function formatDate(ts: number | undefined): string;
+export declare function formatDateTime(ts: number | undefined): string;
+export declare function formatEntityList(entities: EntityResult[], spaces?: Record<string, SpaceInfo>): string;
+export declare function formatEntityDetail(data: {
+    entity: EntityResult["entity"];
+    pins: Pin[];
+    activities: Activity[];
+    openTasks?: OpenTaskSummary[];
+    descriptionPlainText?: string;
+}): string;
+export declare function formatTaskList(tasks: TaskResult[], users?: Record<string, UserInfo>): string;
+export declare function formatTaskDetail(task: TaskResult, users?: Record<string, UserInfo>): string;
+export declare function formatActivityList(activities: Activity[]): string;
+export declare function formatActivityDetail(activity: Activity): string;
+export declare function formatSpacesFooter(spaces: Record<string, SpaceInfo>): string;
+export declare function jsonOutputWithSpaces(data: unknown, spaces: Record<string, SpaceInfo>): string;
+export declare function jsonOutput(data: unknown): string;