dayleaf 0.0.0-stage → 0.1.0

package/README.md

@@ -1,3 +1,125 @@
-# Temporary Holding Version
+# dayleaf — Headless Dayleaf
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+Read and write your [Dayleaf](https://getdayleaf.app) journal from the command
+line or from any AI agent, through the local API the Dayleaf Mac app serves on
+your computer. Nothing leaves your Mac.
+
+```sh
+npx dayleaf add "Ran 5k along the river before work" --planner Health
+npx dayleaf day today
+```
+
+## Setup (one minute)
+
+1. Open **Dayleaf on your Mac** (2.5.0 or later) → Settings → **Headless Dayleaf** → switch it on.
+2. Click **Copy API token**.
+3. In Terminal:
+
+```sh
+npm install -g dayleaf        # or use npx dayleaf … each time
+dayleaf auth <paste-token>
+dayleaf ping                  # → Dayleaf 2.5.0 (292) at http://127.0.0.1:7317 — authenticated
+```
+
+The token is stored in `~/.dayleaf/config.json`. The app must be open for the
+API to answer; it listens only on `127.0.0.1:7317`.
+
+## CLI
+
+```
+dayleaf add "text" [--date today|yesterday|-N|YYYY-MM-DD] [--planner Name] [--source muse]
+dayleaf edit <id> [--content "…"] [--date …] [--planner …]
+dayleaf rm <id>
+dayleaf list [--from …] [--to …] [--planner …] [--q text] [--limit N]
+dayleaf day [date]
+dayleaf show <id>
+dayleaf planners · dayleaf stickers · dayleaf goals [--kind daily|weekly|monthly] [--date …]
+dayleaf stamp <stickerId> [--date …] · dayleaf unstamp <stickerId> [--date …]
+dayleaf goal add "text" [--kind …] [--date …] · dayleaf goal done <id> · dayleaf goal undo <id>
+```
+
+Add `--json` to any command for machine-readable output. A planner named in
+`--planner` is created if it does not exist, so `--planner Weather` just works.
+
+Entries written through the API carry a `source` (default `cli`, or
+`--source muse`) and show up in the app with a small "via muse" label, so your
+own words and an agent's notes never blur.
+
+## MCP server (for agents)
+
+`dayleaf-mcp` is a [Model Context Protocol](https://modelcontextprotocol.io)
+server over stdio. It exposes these tools: `dayleaf_add_entry`,
+`dayleaf_list_entries`, `dayleaf_get_day`, `dayleaf_update_entry`,
+`dayleaf_delete_entry`, `dayleaf_list_planners`, `dayleaf_list_stickers`,
+`dayleaf_stamp_sticker`, `dayleaf_get_goals`, `dayleaf_add_goal`,
+`dayleaf_set_goal`.
+
+Claude Desktop (`claude_desktop_config.json`):
+
+```json
+{ "mcpServers": { "dayleaf": { "command": "npx", "args": ["-y", "dayleaf-mcp"], "env": { "DAYLEAF_SOURCE": "claude" } } } }
+```
+
+Claude Code:
+
+```sh
+claude mcp add dayleaf -- npx -y dayleaf-mcp
+```
+
+Any other MCP-capable agent: run `npx -y dayleaf-mcp` as a stdio server and
+set `DAYLEAF_SOURCE` to the agent's name. Then say things like "log today's
+weather in my Weather planner" or "what did I write last week about sleep?".
+
+## Cloud: agents that are not on your Mac (Meta Muse, hosted assistants)
+
+Switch on **Settings → Cloud access for agents** in Dayleaf (any platform, signed in),
+tap **Create API key**, and point the agent at the cloud endpoint:
+
+- **MCP server URL:** `https://date-jotter-production.up.railway.app/mcp` with header `Authorization: Bearer <API key>`
+- **REST:** same `/v1/…` routes as above at `https://date-jotter-production.up.railway.app`
+- **This CLI:** `dayleaf auth <API key> --url https://date-jotter-production.up.railway.app`
+
+Tell Muse: *"Build a custom integration to Dayleaf. Its MCP server URL is
+https://date-jotter-production.up.railway.app/mcp and it needs a bearer token.
+I want you to be able to write my daily weather and health notes into my journal
+and read back what I wrote, from any future conversation. Connect to it, test
+every capability end to end, show me the results, and save the integration as a
+reusable skill."* Muse asks for the token through its secure credential flow.
+
+The cloud keeps a **text-only** copy of your entries (never photos, audio or video)
+and every device of the account pulls what agents write. Stickers and goals are
+local-API only for now.
+
+## Shell scripts and cron
+
+```sh
+# Every evening: today's weather into the Weather planner
+curl -s "wttr.in/San+Jose?format=%C+%t" | xargs -I{} dayleaf add "{}" --planner Weather --source wttr
+```
+
+## HTTP API
+
+Base URL `http://127.0.0.1:7317`, header `Authorization: Bearer <token>`, JSON in and out.
+
+| Method | Path | Body / query |
+|---|---|---|
+| GET | `/v1/ping` | (no auth) version, build, `authenticated` |
+| GET | `/v1/planners` | |
+| POST | `/v1/planners` | `{name, color?}` |
+| GET | `/v1/entries` | `?from&to&planner&q&limit` |
+| POST | `/v1/entries` | `{content, date?, planner?, source?}` |
+| GET / PATCH / DELETE | `/v1/entries/:id` | PATCH `{content?, date?, planner?}` |
+| GET | `/v1/days/:date` | entries + stickers + daily goals |
+| GET | `/v1/stickers` | catalog + custom stickers |
+| POST | `/v1/days/:date/stickers` | `{id}` |
+| DELETE | `/v1/days/:date/stickers/:id` | |
+| GET | `/v1/goals` | `?kind=daily\|weekly\|monthly&date` |
+| POST | `/v1/goals` | `{kind, date?, text}` |
+| PATCH | `/v1/goals/:id` | `{kind, date?, done?, text?}` |
+
+Dates are `YYYY-MM-DD`. Planners accept an id or a name. Errors are `{error}` with 400/401/404.
+
+## Privacy
+
+The API is loopback-only and off by default. The token is generated on your
+Mac and never sent anywhere; regenerate it from Settings at any time.

package/dist/cli.js

@@ -0,0 +1,190 @@
+#!/usr/bin/env node
+// dayleaf — command-line access to your Dayleaf journal (via the Mac app's
+// local API). `dayleaf help` lists everything.
+import { Dayleaf, DayleafError, loadConfig, saveConfig, resolveDate } from "./client.js";
+const argv = process.argv.slice(2);
+const flags = {};
+const positional = [];
+for (let i = 0; i < argv.length; i++) {
+    const a = argv[i];
+    if (a.startsWith("--")) {
+        const [k, v] = a.slice(2).split("=", 2);
+        if (v !== undefined)
+            flags[k] = v;
+        else if (i + 1 < argv.length && !argv[i + 1].startsWith("--"))
+            flags[k] = argv[++i];
+        else
+            flags[k] = true;
+    }
+    else
+        positional.push(a);
+}
+const cmd = positional.shift() || "help";
+const json = flags.json === true;
+const str = (k) => (typeof flags[k] === "string" ? flags[k] : undefined);
+const HELP = `dayleaf — Headless Dayleaf CLI
+
+Setup (once):
+  dayleaf auth <token>              save the token from Dayleaf → Settings → Headless Dayleaf
+  dayleaf ping                      check the Mac app is reachable
+
+Write:
+  dayleaf add "text" [--date today|yesterday|-N|YYYY-MM-DD] [--planner Name] [--source muse]
+  dayleaf edit <id> [--content "…"] [--date …] [--planner …]
+  dayleaf rm <id>
+  dayleaf stamp <stickerId> [--date …]        dayleaf unstamp <stickerId> [--date …]
+  dayleaf goal add "text" [--kind daily|weekly|monthly] [--date …]
+  dayleaf goal done <id> [--kind …] [--date …]   dayleaf goal undo <id> …
+
+Read:
+  dayleaf list [--from …] [--to …] [--planner …] [--q text] [--limit N]
+  dayleaf day [date]                entries, stickers and goals for a day
+  dayleaf show <id>
+  dayleaf planners                  dayleaf stickers                  dayleaf goals [--kind …] [--date …]
+
+Every command accepts --json for machine-readable output, --url and --token to override config.
+Agents: run \`dayleaf-mcp\` as an MCP server (stdio) to get the same operations as tools.`;
+function out(data, human) { if (json)
+    console.log(JSON.stringify(data, null, 2));
+else
+    human(); }
+function fmtEntry(e, planners) {
+    const src = e.source ? `  (via ${e.source})` : "";
+    const first = e.content.split("\n")[0];
+    return `${e.date}  ${(planners.get(e.plannerId) || e.plannerId).padEnd(12)}  ${first.length > 70 ? first.slice(0, 69) + "…" : first}${src}\n           id ${e.id}`;
+}
+async function main() {
+    if (cmd === "help" || flags.help) {
+        console.log(HELP);
+        return;
+    }
+    if (cmd === "auth") {
+        const token = positional[0] || str("token");
+        if (!token)
+            throw new DayleafError("usage: dayleaf auth <token>");
+        saveConfig({ ...loadConfig(), token, url: str("url") || loadConfig().url });
+        const api = new Dayleaf({ token, url: str("url") });
+        const p = await api.ping();
+        console.log(p.authenticated ? `Connected to Dayleaf ${p.version} (${p.build}) — token saved to ~/.dayleaf/config.json` : "Token saved, but Dayleaf rejected it. Copy it again from Settings → Headless Dayleaf.");
+        return;
+    }
+    const api = new Dayleaf({ url: str("url"), token: str("token"), source: str("source") });
+    const plannerNames = async () => new Map((await api.planners()).planners.map(p => [p.id, p.name]));
+    switch (cmd) {
+        case "ping": {
+            const p = await api.ping();
+            out(p, () => console.log(`Dayleaf ${p.version} (${p.build}) at ${api.url} — ${p.authenticated ? "authenticated" : "NOT authenticated (run dayleaf auth <token>)"}`));
+            break;
+        }
+        case "add": {
+            const content = positional.join(" ") || str("content");
+            if (!content)
+                throw new DayleafError("usage: dayleaf add \"text\" [--date …] [--planner …]");
+            const r = await api.addEntry({ content, date: resolveDate(str("date")), planner: str("planner"), source: str("source") });
+            out(r.entry, () => console.log(`Added to ${r.entry.date} (${r.entry.plannerId}) — id ${r.entry.id}`));
+            break;
+        }
+        case "edit": {
+            const id = positional[0];
+            if (!id)
+                throw new DayleafError("usage: dayleaf edit <id> --content … | --date … | --planner …");
+            const r = await api.updateEntry(id, { content: str("content"), date: str("date") ? resolveDate(str("date")) : undefined, planner: str("planner") });
+            out(r.entry, () => console.log(`Updated ${r.entry.id}`));
+            break;
+        }
+        case "rm":
+        case "delete": {
+            const id = positional[0];
+            if (!id)
+                throw new DayleafError("usage: dayleaf rm <id>");
+            const r = await api.deleteEntry(id);
+            out(r, () => console.log(`Deleted ${r.deleted}`));
+            break;
+        }
+        case "list": {
+            const r = await api.entries({ from: str("from") ? resolveDate(str("from")) : undefined, to: str("to") ? resolveDate(str("to")) : undefined, planner: str("planner"), q: str("q"), limit: str("limit") ? Number(str("limit")) : undefined });
+            const names = await plannerNames();
+            out(r, () => { console.log(r.entries.map(e => fmtEntry(e, names)).join("\n")); console.log(`\n${r.entries.length} of ${r.total} entries`); });
+            break;
+        }
+        case "show": {
+            const id = positional[0];
+            if (!id)
+                throw new DayleafError("usage: dayleaf show <id>");
+            const r = await api.entry(id);
+            out(r.entry, () => console.log(`${r.entry.date} · ${r.entry.plannerId}${r.entry.source ? ` · via ${r.entry.source}` : ""}\n\n${r.entry.content}`));
+            break;
+        }
+        case "day": {
+            const date = resolveDate(positional[0] || str("date"));
+            const d = await api.day(date);
+            const names = await plannerNames();
+            out(d, () => {
+                console.log(`${d.date}`);
+                if (d.stickers.length)
+                    console.log(`stickers: ${d.stickers.map(s => s.count > 1 ? `${s.id}×${s.count}` : s.id).join(", ")}`);
+                if (d.goals.length)
+                    console.log(`goals:\n${d.goals.map(g => `  [${g.done ? "x" : " "}] ${g.text}  (${g.id})`).join("\n")}`);
+                console.log(d.entries.length ? d.entries.map(e => fmtEntry(e, names)).join("\n") : "(no entries)");
+            });
+            break;
+        }
+        case "planners": {
+            const r = await api.planners();
+            out(r, () => console.log(r.planners.map(p => `${p.name.padEnd(16)} ${p.color}  ${p.id}${p.icon ? `  ${p.icon}` : ""}`).join("\n")));
+            break;
+        }
+        case "stickers": {
+            const r = await api.stickers();
+            out(r, () => console.log(r.stickers.map(s => `${s.id.padEnd(14)} ${s.symbol}${s.custom ? "  (custom)" : ""}`).join("\n")));
+            break;
+        }
+        case "stamp": {
+            const id = positional[0];
+            if (!id)
+                throw new DayleafError("usage: dayleaf stamp <stickerId> [--date …]");
+            const r = await api.stamp(resolveDate(str("date")), id);
+            out(r, () => console.log(`Stamped ${r.id} on ${r.date} (×${r.count})`));
+            break;
+        }
+        case "unstamp": {
+            const id = positional[0];
+            if (!id)
+                throw new DayleafError("usage: dayleaf unstamp <stickerId> [--date …]");
+            const r = await api.unstamp(resolveDate(str("date")), id);
+            out(r, () => console.log(`Removed one ${id} from ${r.date}`));
+            break;
+        }
+        case "goals": {
+            const kind = (str("kind") || "daily");
+            const r = await api.goals(kind, str("date") ? resolveDate(str("date")) : undefined);
+            out(r, () => { console.log(`${r.kind} goals · ${r.period}`); console.log(r.goals.length ? r.goals.map(g => `  [${g.done ? "x" : " "}] ${g.text}  (${g.id})`).join("\n") : "  (none)"); if (r.note)
+                console.log(`note: ${r.note}`); });
+            break;
+        }
+        case "goal": {
+            const sub = positional.shift();
+            const kind = (str("kind") || "daily");
+            const date = str("date") ? resolveDate(str("date")) : undefined;
+            if (sub === "add") {
+                const text = positional.join(" ");
+                if (!text)
+                    throw new DayleafError("usage: dayleaf goal add \"text\"");
+                const r = await api.addGoal(text, kind, date);
+                out(r, () => console.log(`Added ${kind} goal for ${r.period} — id ${r.goal.id}`));
+            }
+            else if (sub === "done" || sub === "undo") {
+                const id = positional[0];
+                if (!id)
+                    throw new DayleafError(`usage: dayleaf goal ${sub} <id>`);
+                const r = await api.setGoal(id, { done: sub === "done" }, kind, date);
+                out(r, () => console.log(`${r.goal.done ? "Done" : "Reopened"}: ${r.goal.text}`));
+            }
+            else
+                throw new DayleafError("usage: dayleaf goal add|done|undo …");
+            break;
+        }
+        default: throw new DayleafError(`Unknown command "${cmd}". Run dayleaf help.`);
+    }
+}
+main().catch((e) => { console.error(e instanceof DayleafError ? e.message : (e?.stack || String(e))); process.exit(1); });

package/dist/client.js

@@ -0,0 +1,101 @@
+// Thin client for the Headless Dayleaf local API served by the Mac app
+// (Settings → Headless Dayleaf). Token and base URL come from, in order:
+// flags, DAYLEAF_TOKEN / DAYLEAF_URL, or ~/.dayleaf/config.json.
+import { readFileSync, writeFileSync, mkdirSync, existsSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+export const DEFAULT_URL = "http://127.0.0.1:7317";
+const CONFIG_DIR = join(homedir(), ".dayleaf");
+const CONFIG_FILE = join(CONFIG_DIR, "config.json");
+export function loadConfig() {
+    try {
+        return JSON.parse(readFileSync(CONFIG_FILE, "utf8"));
+    }
+    catch {
+        return {};
+    }
+}
+export function saveConfig(cfg) {
+    if (!existsSync(CONFIG_DIR))
+        mkdirSync(CONFIG_DIR, { recursive: true, mode: 0o700 });
+    writeFileSync(CONFIG_FILE, JSON.stringify(cfg, null, 2) + "\n", { mode: 0o600 });
+}
+export class DayleafError extends Error {
+    status;
+    constructor(message, status) {
+        super(message);
+        this.status = status;
+    }
+}
+export class Dayleaf {
+    url;
+    token;
+    source;
+    constructor(opts = {}) {
+        const cfg = loadConfig();
+        this.url = (opts.url || process.env.DAYLEAF_URL || cfg.url || DEFAULT_URL).replace(/\/$/, "");
+        this.token = opts.token || process.env.DAYLEAF_TOKEN || cfg.token || "";
+        this.source = opts.source || process.env.DAYLEAF_SOURCE || "cli";
+    }
+    async request(method, path, body, query) {
+        const qs = query ? "?" + Object.entries(query).filter(([, v]) => v !== undefined && v !== "").map(([k, v]) => `${encodeURIComponent(k)}=${encodeURIComponent(String(v))}`).join("&") : "";
+        let res;
+        try {
+            res = await fetch(this.url + path + (qs === "?" ? "" : qs), {
+                method,
+                headers: { "content-type": "application/json", authorization: `Bearer ${this.token}`, "x-dayleaf-source": this.source },
+                body: body === undefined ? undefined : JSON.stringify(body),
+            });
+        }
+        catch (e) {
+            throw new DayleafError(`Cannot reach Dayleaf at ${this.url}. Open Dayleaf on this Mac and switch on Settings → Headless Dayleaf. (${e?.cause?.code || e?.message})`);
+        }
+        const text = await res.text();
+        let json = {};
+        try {
+            json = text ? JSON.parse(text) : {};
+        }
+        catch {
+            json = { raw: text };
+        }
+        if (!res.ok) {
+            const hint = res.status === 401 ? " Run `dayleaf auth <token>` with the token from Settings → Headless Dayleaf → Copy API token." : "";
+            throw new DayleafError((json.error || `HTTP ${res.status}`) + hint, res.status);
+        }
+        return json;
+    }
+    ping() { return this.request("GET", "/v1/ping"); }
+    planners() { return this.request("GET", "/v1/planners"); }
+    createPlanner(name, color) { return this.request("POST", "/v1/planners", { name, color }); }
+    entries(q = {}) { return this.request("GET", "/v1/entries", undefined, q); }
+    entry(id) { return this.request("GET", `/v1/entries/${encodeURIComponent(id)}`); }
+    addEntry(e) { return this.request("POST", "/v1/entries", { ...e, source: e.source || this.source }); }
+    updateEntry(id, patch) { return this.request("PATCH", `/v1/entries/${encodeURIComponent(id)}`, patch); }
+    deleteEntry(id) { return this.request("DELETE", `/v1/entries/${encodeURIComponent(id)}`); }
+    day(date) { return this.request("GET", `/v1/days/${date}`); }
+    stickers() { return this.request("GET", "/v1/stickers"); }
+    stamp(date, id) { return this.request("POST", `/v1/days/${date}/stickers`, { id }); }
+    unstamp(date, id) { return this.request("DELETE", `/v1/days/${date}/stickers/${encodeURIComponent(id)}`); }
+    goals(kind = "daily", date) { return this.request("GET", "/v1/goals", undefined, { kind, date }); }
+    addGoal(text, kind = "daily", date) { return this.request("POST", "/v1/goals", { kind, date, text }); }
+    setGoal(id, patch, kind = "daily", date) { return this.request("PATCH", `/v1/goals/${encodeURIComponent(id)}`, { kind, date, ...patch }); }
+}
+export function today() {
+    const d = new Date();
+    return `${d.getFullYear()}-${String(d.getMonth() + 1).padStart(2, "0")}-${String(d.getDate()).padStart(2, "0")}`;
+}
+// "today" | "yesterday" | "-3" (days ago) | YYYY-MM-DD
+export function resolveDate(input) {
+    if (!input || input === "today")
+        return today();
+    const d = new Date();
+    if (input === "yesterday")
+        d.setDate(d.getDate() - 1);
+    else if (/^-\d+$/.test(input))
+        d.setDate(d.getDate() + Number(input));
+    else if (/^\d{4}-\d{2}-\d{2}$/.test(input))
+        return input;
+    else
+        throw new DayleafError(`Unrecognised date "${input}" (use YYYY-MM-DD, today, yesterday or -N)`);
+    return `${d.getFullYear()}-${String(d.getMonth() + 1).padStart(2, "0")}-${String(d.getDate()).padStart(2, "0")}`;
+}

package/dist/mcp.js

@@ -0,0 +1,85 @@
+#!/usr/bin/env node
+// dayleaf-mcp — a Model Context Protocol server (stdio) exposing the Dayleaf
+// journal to agents: Claude, ChatGPT, Muse, anything that speaks MCP.
+// Configure once with `dayleaf auth <token>`; then e.g. in Claude Desktop:
+//   { "mcpServers": { "dayleaf": { "command": "npx", "args": ["-y", "dayleaf-mcp"] } } }
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { z } from "zod";
+import { Dayleaf, DayleafError, resolveDate } from "./client.js";
+const api = new Dayleaf({ source: process.env.DAYLEAF_SOURCE || "agent" });
+const server = new McpServer({ name: "dayleaf", version: "0.1.0" });
+const text = (data) => ({ content: [{ type: "text", text: typeof data === "string" ? data : JSON.stringify(data, null, 2) }] });
+const fail = (e) => ({ content: [{ type: "text", text: e instanceof DayleafError ? e.message : String(e) }], isError: true });
+const dateArg = z.string().optional().describe("YYYY-MM-DD, 'today', 'yesterday' or '-N' days ago. Default today.");
+const kindArg = z.enum(["daily", "weekly", "monthly"]).optional().describe("Goal period. Default daily.");
+server.tool("dayleaf_add_entry", "Write a journal entry into Dayleaf for a date. Use this to log things on the user's behalf (weather, health, screen time, a summary of the day). Entries are shown in the app with a 'via <source>' label.", { content: z.string().describe("The entry text (markdown-free plain text, newlines allowed)."), date: dateArg,
+    planner: z.string().optional().describe("Planner name or id, e.g. 'Health' or 'Weather'. Created if it doesn't exist."),
+    source: z.string().optional().describe("Who is writing, e.g. 'muse'. Defaults to the server's DAYLEAF_SOURCE.") }, async ({ content, date, planner, source }) => { try {
+    return text((await api.addEntry({ content, date: resolveDate(date), planner, source })).entry);
+}
+catch (e) {
+    return fail(e);
+} });
+server.tool("dayleaf_list_entries", "Read journal entries, newest first. Filter by date range, planner, or a text search.", { from: dateArg, to: dateArg, planner: z.string().optional(), q: z.string().optional().describe("Case-insensitive text match."), limit: z.number().int().min(1).max(500).optional() }, async ({ from, to, planner, q, limit }) => { try {
+    return text(await api.entries({ from: from ? resolveDate(from) : undefined, to: to ? resolveDate(to) : undefined, planner, q, limit }));
+}
+catch (e) {
+    return fail(e);
+} });
+server.tool("dayleaf_get_day", "Everything Dayleaf has for one day: entries, stickers and daily goals.", { date: dateArg }, async ({ date }) => { try {
+    return text(await api.day(resolveDate(date)));
+}
+catch (e) {
+    return fail(e);
+} });
+server.tool("dayleaf_update_entry", "Edit an existing entry's text, date or planner.", { id: z.string(), content: z.string().optional(), date: dateArg, planner: z.string().optional() }, async ({ id, content, date, planner }) => { try {
+    return text((await api.updateEntry(id, { content, date: date ? resolveDate(date) : undefined, planner })).entry);
+}
+catch (e) {
+    return fail(e);
+} });
+server.tool("dayleaf_delete_entry", "Delete an entry by id. Only delete entries the agent itself created unless the user asked.", { id: z.string() }, async ({ id }) => { try {
+    return text(await api.deleteEntry(id));
+}
+catch (e) {
+    return fail(e);
+} });
+server.tool("dayleaf_list_planners", "List the user's planners (journals/notebooks) with ids and colours.", {}, async () => { try {
+    return text(await api.planners());
+}
+catch (e) {
+    return fail(e);
+} });
+server.tool("dayleaf_list_stickers", "List sticker ids that can be stamped on a day (catalog + the user's custom stickers).", {}, async () => { try {
+    return text(await api.stickers());
+}
+catch (e) {
+    return fail(e);
+} });
+server.tool("dayleaf_stamp_sticker", "Stamp a sticker on a day (e.g. 'workout', 'travel'). Repeat to add another copy.", { id: z.string(), date: dateArg }, async ({ id, date }) => { try {
+    return text(await api.stamp(resolveDate(date), id));
+}
+catch (e) {
+    return fail(e);
+} });
+server.tool("dayleaf_get_goals", "Read daily, weekly or monthly goals for a period.", { kind: kindArg, date: dateArg }, async ({ kind, date }) => { try {
+    return text(await api.goals(kind || "daily", date ? resolveDate(date) : undefined));
+}
+catch (e) {
+    return fail(e);
+} });
+server.tool("dayleaf_add_goal", "Add a goal to a daily/weekly/monthly list.", { text: z.string(), kind: kindArg, date: dateArg }, async ({ text: t, kind, date }) => { try {
+    return text(await api.addGoal(t, kind || "daily", date ? resolveDate(date) : undefined));
+}
+catch (e) {
+    return fail(e);
+} });
+server.tool("dayleaf_set_goal", "Mark a goal done/undone or change its text.", { id: z.string(), kind: kindArg, date: dateArg, done: z.boolean().optional(), text: z.string().optional() }, async ({ id, kind, date, done, text: t }) => { try {
+    return text(await api.setGoal(id, { done, text: t }, kind || "daily", date ? resolveDate(date) : undefined));
+}
+catch (e) {
+    return fail(e);
+} });
+const transport = new StdioServerTransport();
+await server.connect(transport);

package/package.json

@@ -1,6 +1,15 @@
 {
   "name": "dayleaf",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.1.0",
+  "description": "Headless Dayleaf: CLI and MCP server for reading and writing your Dayleaf journal on the Mac",
+  "license": "MIT",
+  "type": "module",
+  "bin": { "dayleaf": "dist/cli.js", "dayleaf-mcp": "dist/mcp.js" },
+  "files": ["dist", "README.md"],
+  "scripts": { "build": "tsc -p tsconfig.json", "prepublishOnly": "npm run build" },
+  "engines": { "node": ">=18" },
+  "keywords": ["dayleaf", "journal", "diary", "mcp", "agent", "cli"],
+  "homepage": "https://getdayleaf.app/headless.html",
+  "dependencies": { "@modelcontextprotocol/sdk": "^1.12.0", "zod": "^3.23.8" },
+  "devDependencies": { "typescript": "^5.6.0", "@types/node": "^22.0.0" }
+}