shelvd-mcp 0.0.0-stage → 0.1.0

package/dist/cli.js

@@ -0,0 +1,364 @@
+#!/usr/bin/env node
+
+// src/cli.ts
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+
+// src/server.ts
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+
+// ../shared/src/index.ts
+import { z } from "zod";
+var UPGRADE_URL = "https://shelvd.dev/pro";
+var TOOLS = {
+  park: "park_idea",
+  list: "list_ideas",
+  get: "get_idea",
+  complete: "complete_idea",
+  snooze: "snooze_idea",
+  delete: "delete_idea",
+  clear: "clear_ideas"
+};
+var parkIdeaInput = {
+  title: z.string().min(1).max(200),
+  details: z.string().max(5e3).optional(),
+  project: z.string().max(80).optional(),
+  due: z.string().optional().describe("ISO date or natural text like 'friday 3pm'"),
+  nagEveryMinutes: z.number().int().positive().optional(),
+  context: z.object({
+    source: z.string().optional(),
+    repo: z.string().optional(),
+    branch: z.string().optional(),
+    files: z.array(z.string()).max(20).optional(),
+    summary: z.string().max(1e3).optional()
+  }).optional()
+};
+var listIdeasInput = {
+  project: z.string().optional(),
+  status: z.enum(["parked", "due", "snoozed", "done", "all"]).optional(),
+  from: z.string().optional(),
+  to: z.string().optional(),
+  limit: z.number().int().positive().max(200).optional()
+};
+var idInput = { id: z.string().min(1) };
+var snoozeIdeaInput = {
+  id: z.string().min(1),
+  until: z.string().optional(),
+  minutes: z.number().int().positive().optional()
+};
+var clearIdeasInput = {
+  scope: z.string().describe("'done', 'all', or 'project:<name>'"),
+  confirm: z.boolean().optional()
+};
+
+// src/dates.ts
+import * as chrono from "chrono-node";
+function parseDue(text, now = /* @__PURE__ */ new Date()) {
+  const [hit] = chrono.parse(text, now, { forwardDate: true });
+  if (!hit) return null;
+  const d = hit.start.date();
+  if (!hit.start.isCertain("hour")) d.setHours(10, 0, 0, 0);
+  return d;
+}
+function startOfDay(d) {
+  const s = new Date(d);
+  s.setHours(0, 0, 0, 0);
+  return s;
+}
+function fmt(d) {
+  const x = new Date(d);
+  const p = (n) => String(n).padStart(2, "0");
+  return `${x.getFullYear()}-${p(x.getMonth() + 1)}-${p(x.getDate())} ${p(x.getHours())}:${p(x.getMinutes())}`;
+}
+
+// src/store.ts
+import { randomBytes } from "crypto";
+import { mkdirSync, readFileSync, renameSync, writeFileSync } from "fs";
+import { homedir } from "os";
+import { join } from "path";
+var CorruptStoreError = class extends Error {
+  constructor(file) {
+    super(`${file} is unreadable. Left untouched; fix or move it, then retry.`);
+  }
+};
+var Store = class {
+  file;
+  constructor(dir = process.env.SHELVD_DIR ?? join(homedir(), ".shelvd")) {
+    this.dir = dir;
+    this.file = join(dir, "ideas.json");
+  }
+  dir;
+  read() {
+    let raw;
+    try {
+      raw = readFileSync(this.file, "utf8");
+    } catch (e) {
+      if (e.code === "ENOENT") return [];
+      throw e;
+    }
+    try {
+      const parsed = JSON.parse(raw);
+      if (parsed.version !== 1 || !Array.isArray(parsed.ideas)) throw new Error();
+      return parsed.ideas;
+    } catch {
+      throw new CorruptStoreError(this.file);
+    }
+  }
+  // shortcut: re-reads before each write but takes no lock, so two clients writing in the same
+  // millisecond can drop one write. Add a lockfile if that ever happens in practice.
+  update(fn) {
+    const ideas = this.read();
+    const result = fn(ideas);
+    mkdirSync(this.dir, { recursive: true });
+    const tmp = `${this.file}.${process.pid}.tmp`;
+    writeFileSync(tmp, JSON.stringify({ version: 1, ideas }, null, 2));
+    renameSync(tmp, this.file);
+    return result;
+  }
+  newId(ideas) {
+    for (; ; ) {
+      const id = randomBytes(4).toString("hex").slice(0, 6);
+      if (!ideas.some((i) => i.id === id)) return id;
+    }
+  }
+};
+
+// src/tools.ts
+var err = (text) => ({ text, isError: true });
+var pipe = (s) => s.replace(/\|/g, "\\|").replace(/\n/g, " ");
+function label(i, now) {
+  if (i.status === "done") return "done";
+  if (i.dueAt && new Date(i.dueAt) <= now) {
+    return new Date(i.dueAt) < startOfDay(now) ? "overdue" : "due";
+  }
+  if (i.status === "snoozed") return "snoozed";
+  return i.dueAt ? "upcoming" : "parked";
+}
+var RANK = { overdue: 0, due: 1, snoozed: 2, upcoming: 2, parked: 3, done: 4 };
+function sortIdeas(ideas, now) {
+  return [...ideas].sort((a, b) => {
+    const r = RANK[label(a, now)] - RANK[label(b, now)];
+    if (r) return r;
+    return (a.dueAt ?? "").localeCompare(b.dueAt ?? "");
+  });
+}
+function table(ideas, now) {
+  const rows = ideas.map(
+    (i) => `| ${pipe(i.title)} | ${pipe(i.project)} | ${label(i, now)} | ${i.dueAt ? fmt(i.dueAt) : "-"} | ${i.id} |`
+  );
+  return ["| Title | Project | Status | Due | ID |", "| --- | --- | --- | --- | --- |", ...rows].join("\n");
+}
+function dueSummary(ideas, now) {
+  const due = sortIdeas(ideas, now).filter((i) => ["overdue", "due"].includes(label(i, now)));
+  if (!due.length) return "";
+  const lines = due.map((i) => `- ${i.title} [${i.project}] ${label(i, now)} ${fmt(i.dueAt)} (id ${i.id})`);
+  return `${due.length} idea${due.length > 1 ? "s" : ""} due today or overdue:
+${lines.join("\n")}`;
+}
+var find = (ideas, id) => ideas.find((i) => i.id === id);
+var touch = (i, now, event) => {
+  i.updatedAt = now.toISOString();
+  i.history.push({ at: i.updatedAt, event });
+};
+function parkIdea(store2, input, now = /* @__PURE__ */ new Date()) {
+  const due = input.due ? parseDue(input.due, now) : null;
+  const project = input.project?.trim() || input.context?.repo?.trim() || "Inbox";
+  const idea = store2.update((ideas) => {
+    const at = now.toISOString();
+    const i = {
+      id: store2.newId(ideas),
+      title: input.title,
+      details: input.details,
+      project,
+      status: "parked",
+      dueAt: due?.toISOString() ?? null,
+      nagEveryMinutes: input.nagEveryMinutes,
+      context: input.context,
+      notes: [],
+      history: [{ at, event: "parked" }],
+      completedAt: null,
+      createdAt: at,
+      updatedAt: at
+    };
+    ideas.push(i);
+    return i;
+  });
+  const parts = [`Parked "${idea.title}" in ${project} (id ${idea.id}).`];
+  if (due) parts.push(`Due ${fmt(due)}.`);
+  else if (input.due) parts.push("Could not read the date, parked without one.");
+  else parts.push("No due date.");
+  if (input.nagEveryMinutes) parts.push(`Phone reminders need the hosted Pro version: ${UPGRADE_URL}`);
+  return { text: parts.join(" "), data: idea };
+}
+function listIdeas(store2, input, now = /* @__PURE__ */ new Date()) {
+  const all = store2.read();
+  let ideas = all;
+  if (input.project) {
+    const p = input.project.toLowerCase();
+    ideas = ideas.filter((i) => i.project.toLowerCase() === p);
+    if (!ideas.length && !all.some((i) => i.project.toLowerCase() === p)) {
+      const known = [...new Set(all.map((i) => i.project))];
+      return err(`Unknown project "${input.project}". Known projects: ${known.join(", ") || "none"}.`);
+    }
+  }
+  const status = input.status ?? "parked,snoozed";
+  ideas = ideas.filter((i) => {
+    if (status === "all") return true;
+    if (status === "due") return ["overdue", "due"].includes(label(i, now));
+    if (status === "parked,snoozed") return i.status !== "done";
+    return i.status === status;
+  });
+  const from = input.from ? parseDue(input.from, now) : null;
+  const to = input.to ? parseDue(input.to, now) : null;
+  if (from || to) {
+    ideas = ideas.filter((i) => i.dueAt && (!from || new Date(i.dueAt) >= from) && (!to || new Date(i.dueAt) <= to));
+  }
+  ideas = sortIdeas(ideas, now);
+  const limit = input.limit ?? 20;
+  const shown = ideas.slice(0, limit);
+  if (!shown.length) return { text: "No ideas found.", data: [] };
+  const more = ideas.length > shown.length ? `
+
+${ideas.length - shown.length} more not shown.` : "";
+  return { text: table(shown, now) + more, data: shown };
+}
+function getIdea(store2, id) {
+  const i = find(store2.read(), id);
+  return i ? { text: `${i.title} [${i.project}]`, data: i } : err(`No idea with id ${id}.`);
+}
+function completeIdea(store2, id, now = /* @__PURE__ */ new Date()) {
+  const i = store2.update((ideas) => {
+    const x = find(ideas, id);
+    if (x) {
+      x.status = "done";
+      x.completedAt = now.toISOString();
+      touch(x, now, "done");
+    }
+    return x;
+  });
+  return i ? { text: `Marked done: "${i.title}".`, data: i } : err(`No idea with id ${id}.`);
+}
+function snoozeIdea(store2, input, now = /* @__PURE__ */ new Date()) {
+  let until = null;
+  if (input.minutes) until = new Date(now.getTime() + input.minutes * 6e4);
+  else if (input.until) until = parseDue(input.until, now);
+  if (!until) return err("Give a readable `until` date or `minutes`.");
+  const i = store2.update((ideas) => {
+    const x = find(ideas, input.id);
+    if (x) {
+      x.status = "snoozed";
+      x.dueAt = until.toISOString();
+      touch(x, now, `snoozed until ${x.dueAt}`);
+    }
+    return x;
+  });
+  return i ? { text: `Snoozed "${i.title}" until ${fmt(until)}.`, data: i } : err(`No idea with id ${input.id}.`);
+}
+function deleteIdea(store2, id) {
+  const gone = store2.update((ideas) => {
+    const n = ideas.findIndex((i) => i.id === id);
+    return n < 0 ? void 0 : ideas.splice(n, 1)[0];
+  });
+  return gone ? { text: `Deleted "${gone.title}".`, data: gone } : err(`No idea with id ${id}.`);
+}
+function clearIdeas(store2, input) {
+  const scope = input.scope.trim();
+  let match;
+  if (scope === "done") match = (i) => i.status === "done";
+  else if (scope === "all") match = () => true;
+  else if (scope.startsWith("project:")) {
+    const name = scope.slice("project:".length).trim().toLowerCase();
+    match = (i) => i.project.toLowerCase() === name;
+  } else return err("scope must be 'done', 'all', or 'project:<name>'.");
+  if (!input.confirm) {
+    const hits = store2.read().filter(match);
+    const list = hits.map((i) => `- ${i.title} (${i.id})`).join("\n");
+    return {
+      text: `Would delete ${hits.length} ideas. Nothing deleted. Ask the user, then call again with confirm: true.${list ? "\n" + list : ""}`,
+      data: hits
+    };
+  }
+  const removed = store2.update((ideas) => {
+    const keep = ideas.filter((i) => !match(i));
+    const out = ideas.length - keep.length;
+    ideas.splice(0, ideas.length, ...keep);
+    return out;
+  });
+  return { text: `Deleted ${removed} ideas.`, data: { deleted: removed } };
+}
+
+// src/server.ts
+function wrap(run) {
+  let r;
+  try {
+    r = run();
+  } catch (e) {
+    r = { text: e instanceof Error ? e.message : String(e), isError: true };
+  }
+  const content = [{ type: "text", text: r.text }];
+  if (r.data !== void 0) content.push({ type: "text", text: JSON.stringify(r.data) });
+  return { content, isError: r.isError };
+}
+function buildServer(store2) {
+  let instructions = "Shelvd parks ideas for later. Use park_idea when the user wants to save an idea for later.";
+  try {
+    const due = dueSummary(store2.read(), /* @__PURE__ */ new Date());
+    if (due) instructions += `
+
+Mention this to the user in your first reply:
+${due}`;
+  } catch {
+  }
+  const s = new McpServer({ name: "shelvd", version: "0.1.0" }, { instructions });
+  s.registerTool(TOOLS.park, {
+    description: "Park an idea for later, with an optional due date (natural language ok), project and context.",
+    inputSchema: parkIdeaInput
+  }, (a) => wrap(() => parkIdea(store2, a)));
+  s.registerTool(TOOLS.list, {
+    description: "List parked ideas as a markdown table. Show the table to the user exactly as returned; do not reformat or drop dates and ids.",
+    inputSchema: listIdeasInput
+  }, (a) => wrap(() => listIdeas(store2, a)));
+  s.registerTool(TOOLS.get, {
+    description: "Get one idea with full context, notes and history.",
+    inputSchema: idInput
+  }, (a) => wrap(() => getIdea(store2, a.id)));
+  s.registerTool(TOOLS.complete, {
+    description: "Mark an idea done.",
+    inputSchema: idInput
+  }, (a) => wrap(() => completeIdea(store2, a.id)));
+  s.registerTool(TOOLS.snooze, {
+    description: "Move an idea's due date later. Give `until` (date text) or `minutes`.",
+    inputSchema: snoozeIdeaInput
+  }, (a) => wrap(() => snoozeIdea(store2, a)));
+  s.registerTool(TOOLS.delete, {
+    description: "Permanently delete ONE idea by exact id. Confirm with the user first. Never guess an id from a vague title; list ideas to find it.",
+    inputSchema: idInput
+  }, (a) => wrap(() => deleteIdea(store2, a.id)));
+  s.registerTool(TOOLS.clear, {
+    description: "Delete many ideas: scope 'done', 'all' or 'project:<name>'. Without confirm=true it only previews. Show the preview to the user and call again with confirm=true only after they approve.",
+    inputSchema: clearIdeasInput
+  }, (a) => wrap(() => clearIdeas(store2, a)));
+  return s;
+}
+
+// src/cli.ts
+var HOOK = JSON.stringify(
+  { hooks: { SessionStart: [{ hooks: [{ type: "command", command: "npx -y shelvd-mcp due" }] }] } },
+  null,
+  2
+);
+var cmd = process.argv[2];
+var store = new Store();
+if (cmd === "due") {
+  try {
+    const out = dueSummary(store.read(), /* @__PURE__ */ new Date());
+    if (out) console.log(out);
+  } catch (e) {
+    console.log(`shelvd: ${e instanceof Error ? e.message : e}`);
+  }
+} else if (cmd === "hook") {
+  console.log(`Add this to ~/.claude/settings.json (Shelvd never edits it for you):
+
+${HOOK}`);
+} else {
+  await buildServer(store).connect(new StdioServerTransport());
+}

package/package.json

@@ -1,6 +1,18 @@
 {
   "name": "shelvd-mcp",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.1.0",
+  "description": "Shelvd: park ideas from your AI tool. Local, private MCP server.",
+  "type": "module",
+  "bin": { "shelvd-mcp": "dist/cli.js" },
+  "files": ["dist"],
+  "scripts": {
+    "build": "tsup",
+    "test": "vitest run"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.0.0",
+    "chrono-node": "^2.7.0",
+    "zod": "^3.23.8"
+  },
+  "devDependencies": { "@shelvd/shared": "*" }
+}

package/README.md

@@ -1,3 +0,0 @@
-# Temporary Holding Version
-
-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.