@harborppm/cli 0.76.0 → 0.77.0

package/dist/words.mjs

@@ -0,0 +1,301 @@
+// Built from src/lib/plain-words.ts by cli/build.mjs. Edit the source, not this file.
+// src/lib/plain-words.ts
+const DAYS = [
+	"sunday",
+	"monday",
+	"tuesday",
+	"wednesday",
+	"thursday",
+	"friday",
+	"saturday"
+];
+const MONTHS = [
+	"january",
+	"february",
+	"march",
+	"april",
+	"may",
+	"june",
+	"july",
+	"august",
+	"september",
+	"october",
+	"november",
+	"december"
+];
+const NUMBER_WORDS = {
+	a: 1,
+	an: 1,
+	one: 1,
+	two: 2,
+	three: 3,
+	four: 4,
+	five: 5,
+	six: 6,
+	seven: 7,
+	eight: 8,
+	nine: 9,
+	ten: 10
+};
+const loose = (s) => s.toLowerCase().replace(/[^\p{L}\p{N}]+/gu, "");
+function shift(iso, days) {
+	const d = /* @__PURE__ */ new Date(`${iso}T12:00:00Z`);
+	d.setUTCDate(d.getUTCDate() + days);
+	return d.toISOString().slice(0, 10);
+}
+function weekday(iso) {
+	return (/* @__PURE__ */ new Date(`${iso}T12:00:00Z`)).getUTCDay();
+}
+function dayOf(y, m, d) {
+	const date = new Date(Date.UTC(y, m - 1, d, 12));
+	if (date.getUTCMonth() !== m - 1 || date.getUTCDate() !== d) return null;
+	return date.toISOString().slice(0, 10);
+}
+/** A month and day with no year: this year's, or next year's once it has passed. */
+function nextMonthDay(today, m, d) {
+	const year = Number(today.slice(0, 4));
+	const thisYear = dayOf(year, m, d);
+	if (!thisYear) return null;
+	return thisYear >= today ? thisYear : dayOf(year + 1, m, d);
+}
+const monthIndex = (word) => {
+	const w = word.toLowerCase().replace(/\.$/, "");
+	if (w.length < 3) return -1;
+	return MONTHS.findIndex((m) => m.startsWith(w) && (w.length >= 3 || m === w));
+};
+const DAY_WORD = "(?:sun|mon|tues?|wed(?:nes)?|thu(?:rs?)?|fri|sat(?:ur)?)(?:day)?";
+const MONTH_WORD = "(?:jan|feb|mar|apr|may|jun|jul|aug|sept?|oct|nov|dec)[a-z]*\\.?";
+/** Every way of saying a day, longest first so "next friday" wins over "friday". */
+const WHEN = [
+	"today",
+	"tonight",
+	"tomorrow",
+	"tmrw",
+	"the day after tomorrow",
+	"end of (?:the )?week",
+	"this week",
+	"next week",
+	"end of (?:the )?month",
+	"next month",
+	`in (?:\\d{1,2}|a|an|one|two|three|four|five|six|seven|eight|nine|ten) (?:days?|weeks?)`,
+	`(?:this |next |on )?${DAY_WORD}`,
+	`${MONTH_WORD} \\d{1,2}(?:st|nd|rd|th)?(?:,? \\d{4})?`,
+	`\\d{1,2}(?:st|nd|rd|th)? (?:of )?${MONTH_WORD}(?:,? \\d{4})?`,
+	"\\d{4}-\\d{1,2}-\\d{1,2}",
+	"\\d{1,2}/\\d{1,2}(?:/\\d{2,4})?"
+].join("|");
+const LEAD = "(?:by|due|due on|due by|on|before|until|till)";
+/** The day a phrase names, or null when it names none. */
+function dayFromWords(phrase, today) {
+	const p = phrase.toLowerCase().replace(/\s+/g, " ").replace(/^on /, "").trim();
+	if (p === "today" || p === "tonight") return today;
+	if (p === "tomorrow" || p === "tmrw") return shift(today, 1);
+	if (p === "the day after tomorrow") return shift(today, 2);
+	const dow = weekday(today);
+	if (/^end of (the )?week$/.test(p) || p === "this week") return shift(today, (5 - dow + 7) % 7);
+	if (p === "next week") return shift(today, (1 - dow + 7) % 7 || 7);
+	if (p === "next month") {
+		const [y, m] = [Number(today.slice(0, 4)), Number(today.slice(5, 7))];
+		return m === 12 ? dayOf(y + 1, 1, 1) : dayOf(y, m + 1, 1);
+	}
+	if (/^end of (the )?month$/.test(p)) {
+		const [y, m] = [Number(today.slice(0, 4)), Number(today.slice(5, 7))];
+		return shift(m === 12 ? dayOf(y + 1, 1, 1) : dayOf(y, m + 1, 1), -1);
+	}
+	let m = p.match(/^in (\w+) (day|week)s?$/);
+	if (m) {
+		const n = /^\d+$/.test(m[1]) ? Number(m[1]) : NUMBER_WORDS[m[1]];
+		if (n == null || n > 366) return null;
+		return shift(today, m[2] === "week" ? n * 7 : n);
+	}
+	m = p.match(/^(this |next )?([a-z]+)$/);
+	if (m) {
+		const target = DAYS.findIndex((d) => d.startsWith(m[2].slice(0, 3)) && m[2].length >= 3);
+		if (target >= 0 && new RegExp(`^${DAY_WORD}$`).test(m[2])) {
+			const ahead = (target - dow + 7) % 7 || 7;
+			return shift(today, m[1] === "next " ? ahead + 7 : ahead);
+		}
+	}
+	m = p.match(/^([a-z]+\.?) (\d{1,2})(?:st|nd|rd|th)?(?:,? (\d{4}))?$/);
+	if (m && monthIndex(m[1]) >= 0) {
+		const month = monthIndex(m[1]) + 1;
+		return m[3] ? dayOf(Number(m[3]), month, Number(m[2])) : nextMonthDay(today, month, Number(m[2]));
+	}
+	m = p.match(/^(\d{1,2})(?:st|nd|rd|th)? (?:of )?([a-z]+\.?)(?:,? (\d{4}))?$/);
+	if (m && monthIndex(m[2]) >= 0) {
+		const month = monthIndex(m[2]) + 1;
+		return m[3] ? dayOf(Number(m[3]), month, Number(m[1])) : nextMonthDay(today, month, Number(m[1]));
+	}
+	m = p.match(/^(\d{4})-(\d{1,2})-(\d{1,2})$/);
+	if (m) return dayOf(Number(m[1]), Number(m[2]), Number(m[3]));
+	m = p.match(/^(\d{1,2})\/(\d{1,2})(?:\/(\d{2,4}))?$/);
+	if (m) {
+		if (!m[3]) return nextMonthDay(today, Number(m[1]), Number(m[2]));
+		return dayOf(Number(m[3]) < 100 ? 2e3 + Number(m[3]) : Number(m[3]), Number(m[1]), Number(m[2]));
+	}
+	return null;
+}
+const PRIORITY_WORDS = {
+	urgent: "urgent",
+	asap: "urgent",
+	top: "urgent",
+	p0: "urgent",
+	high: "high",
+	p1: "high",
+	medium: "medium",
+	normal: "medium",
+	p2: "medium",
+	low: "low",
+	p3: "low"
+};
+/** Removes found spans from the text, tidying the spaces and commas they leave. */
+function without(text, spans) {
+	let out = text;
+	for (const s of [...spans].sort((a, b) => b.start - a.start)) out = `${out.slice(0, s.start)} ${out.slice(s.end)}`;
+	return out.replace(/\s+([,.;:!?])/g, "$1").replace(/[,;:]+([,.;:!?])/g, "$1").replace(/\s{2,}/g, " ").replace(/(?:[\s,;:–—-]+)$/u, "").replace(/^[\s,;:]+/, "").trim();
+}
+/** What a new task's words say, and the title they leave. */
+function readTaskWords(input, ctx) {
+	const skip = ctx.skip ?? /* @__PURE__ */ new Set();
+	const text = input;
+	const taken = [];
+	const free = (start, end) => !taken.some((t) => start < t.end && end > t.start);
+	let priority = null;
+	if (!skip.has("priority")) for (const re of [
+		/(?:^|\s)!(urgent|asap|high|medium|normal|low|p[0-3])\b/gi,
+		/(?:^|[\s,])(urgent|top|high|medium|normal|low) priority\b/gi,
+		/(?:^|[\s,])priority (urgent|high|medium|normal|low|p[0-3])\b/gi,
+		/(?:^|[\s,])(urgent|asap)$/gi
+	]) {
+		const m = re.exec(text);
+		if (m) {
+			const lead = m[0].length - m[0].trimStart().length;
+			const start = m.index + lead + (m[0].trimStart().startsWith(",") ? 1 : 0);
+			priority = {
+				value: PRIORITY_WORDS[m[1].toLowerCase()],
+				start,
+				end: m.index + m[0].length
+			};
+			taken.push(priority);
+			break;
+		}
+	}
+	let project = null;
+	if (!skip.has("project")) for (const m of text.matchAll(/(?:^|\s)#([\p{L}\p{N}_-]+)/gu)) {
+		const key = loose(m[1]);
+		if (!key) continue;
+		const exact = ctx.projects.filter((p) => loose(p.name) === key);
+		const begins = ctx.projects.filter((p) => loose(p.name).startsWith(key));
+		const hit = exact.length === 1 ? exact[0] : begins.length === 1 ? begins[0] : null;
+		if (!hit) continue;
+		const start = m.index + (m[0].length - m[0].trimStart().length);
+		project = {
+			value: hit.id,
+			start,
+			end: m.index + m[0].length
+		};
+		taken.push(project);
+		break;
+	}
+	let owner = null;
+	if (!skip.has("owner")) {
+		const byKey = (key) => {
+			const full = ctx.people.filter((p) => loose(p.name) === key);
+			if (full.length === 1) return full[0];
+			const first = ctx.people.filter((p) => loose(p.name.split(/\s+/)[0] ?? "") === key);
+			if (first.length === 1) return first[0];
+			const begins = ctx.people.filter((p) => loose(p.name).startsWith(key));
+			return key.length >= 3 && begins.length === 1 ? begins[0] : null;
+		};
+		for (const m of text.matchAll(/(?:^|\s)@([\p{L}\p{N}._-]+)/gu)) {
+			const hit = byKey(loose(m[1]));
+			if (!hit) continue;
+			const start = m.index + (m[0].length - m[0].trimStart().length);
+			if (!free(start, m.index + m[0].length)) continue;
+			owner = {
+				value: hit.id,
+				start,
+				end: m.index + m[0].length
+			};
+			break;
+		}
+		if (!owner) for (const m of text.matchAll(/(?:^|[\s,])(?:assign(?:ed)? (?:it )?to|owner(?: is)?:?) (\p{L}+(?: \p{L}+)?)/giu)) {
+			const words = m[1].split(" ");
+			const two = words.length === 2 ? byKey(loose(m[1])) : null;
+			const one = byKey(loose(words[0]));
+			const hit = two ?? one;
+			if (!hit) continue;
+			const lead = m[0].length - m[0].replace(/^[\s,]+/, "").length;
+			const start = m.index + lead;
+			const end = two ? m.index + m[0].length : m.index + m[0].length - (words.length === 2 ? words[1].length + 1 : 0);
+			if (!free(start, end)) continue;
+			owner = {
+				value: hit.id,
+				start,
+				end
+			};
+			break;
+		}
+		if (owner) taken.push(owner);
+	}
+	let due = null;
+	if (!skip.has("due")) {
+		const led = new RegExp(`(?:^|[\\s,])(${LEAD} (${WHEN}))(?=$|[\\s,.;:!?])`, "gi");
+		for (const m of text.matchAll(led)) {
+			const day = dayFromWords(m[2], ctx.today);
+			if (!day) continue;
+			const start = m.index + m[0].indexOf(m[1]);
+			const end = start + m[1].length;
+			if (!free(start, end)) continue;
+			due = {
+				value: day,
+				start,
+				end
+			};
+			break;
+		}
+		if (!due) {
+			const rest = without(text, taken);
+			const tail = new RegExp(`(?:^|[\\s,])(${WHEN})[.!]?$`, "i").exec(rest);
+			const short = tail && /^(?:sun|mon|tue|wed|thu|fri|sat)$/i.test(tail[1]);
+			const said = tail && /\b(?:to|for|from|after|with|since)$/i.test(rest.slice(0, tail.index).trimEnd());
+			if (tail && !short && !said && rest.trim().length > tail[1].length) {
+				const day = dayFromWords(tail[1], ctx.today);
+				if (day) {
+					const at = text.toLowerCase().lastIndexOf(tail[1].toLowerCase());
+					if (at >= 0 && free(at, at + tail[1].length)) due = {
+						value: day,
+						start: at,
+						end: at + tail[1].length
+					};
+				}
+			}
+		}
+		if (due) taken.push(due);
+	}
+	const span = (f) => f ? text.slice(f.start, f.end).trim() : "";
+	let title = without(text, taken);
+	const first = text.search(/\S/);
+	if (taken.some((t) => t.start === first)) title = title.charAt(0).toUpperCase() + title.slice(1);
+	return {
+		title,
+		due: due ? {
+			value: due.value,
+			text: span(due)
+		} : null,
+		owner: owner ? {
+			value: owner.value,
+			text: span(owner)
+		} : null,
+		priority: priority ? {
+			value: priority.value,
+			text: span(priority)
+		} : null,
+		project: project ? {
+			value: project.value,
+			text: span(project)
+		} : null
+	};
+}
+
+export { dayFromWords, readTaskWords };

package/lib/cli.mjs

@@ -64,6 +64,7 @@ import {
 import { colourDepth, logoLines } from "./logo.mjs";
 import { HarborError, createClient } from "./mcp.mjs";
 import { jsonText, plain } from "./plain.mjs";
+import { dayFromWords, readTaskWords } from "./words.mjs";
 import {
   FETCH_LIMIT,
   SHELLS,
@@ -164,10 +165,14 @@ export const HELP = `harbor: Harbor from the terminal
                      [--also "NAME, NAME"] [--due DATE|pilot]
                      [--priority low|medium|high|urgent]
                      [--status S] [--comment TEXT] [--over-limit] [--dry-run]
-                                              with no TITLE: one title a line
-                                              from stdin; --due pilot takes the
-                                              date the owner's queue suggests
-                                              (harbor help add)
+                     [--literal]
+                                              reads plain words in TITLE as the
+                                              website does: @name, by friday,
+                                              !high, #project (--literal: keep
+                                              them); with no TITLE: one title a
+                                              line from stdin; --due pilot takes
+                                              the date the owner's queue
+                                              suggests (harbor help add)
   harbor start TASK | submit TASK | done TASK [--confirm] [--over-limit]
                                               move a task to In play, In review
                                               or Done
@@ -486,7 +491,11 @@ function daysToWeekday(v, today) {
   return i < 0 ? null : (i - today.getDay() + 7) % 7;
 }
 
-/** --due as people say it: today, tomorrow, friday, +3, or a date. Anything else goes to Harbor to judge. */
+/**
+ * --due as people say it: today, tomorrow, friday, +3, or a date, and the
+ * rest of what the website's new task box reads ("next friday", "in two
+ * weeks", "Nov 15"). Anything else goes to Harbor to judge.
+ */
 export function dueDate(v, today = new Date()) {
   if (v === undefined || v === null) return v;
   const words = { today: 0, tomorrow: 1 };
@@ -498,11 +507,64 @@ export function dueDate(v, today = new Date()) {
         : /^[a-z]+$/i.test(v)
           ? daysToWeekday(v, today)
           : null;
-  if (days === null) return v;
+  if (days === null) return (typeof v === "string" && dayFromWords(v, todayLocal(today))) || v;
   const d = new Date(today.getFullYear(), today.getMonth(), today.getDate() + days);
   return todayLocal(d);
 }
 
+/**
+ * Each title read in plain words, as the website's new task box reads it:
+ * "Book the venue @Quinn by Friday !high #Website". A flag given says that
+ * thing itself, so its words stay in the title. The crew and the projects
+ * are asked for only when a title could name one.
+ */
+async function readTitles(client, harbor, titles, values, today = todayLocal()) {
+  const could = (re) => titles.some((t) => re.test(t));
+  const people =
+    values.assignee === undefined && could(/(?:^|\s)@|\bassign|\bowner\b/i)
+      ? await client
+          .call("crew_clocks", { harbor })
+          .then((r) => [...(r.clocks ?? []).map((c) => c.who), ...(r.noTimeZone ?? [])])
+          .catch(() => [])
+      : [];
+  const projects =
+    values.project === undefined && could(/(?:^|\s)#/)
+      ? await client
+          .call("list_projects", { harbor, limit: 100 })
+          .then((r) => (r.projects ?? []).map((p) => ({ id: p.name, name: p.name })))
+          .catch(() => [])
+      : [];
+  const skip = new Set(
+    [
+      values.assignee !== undefined && "owner",
+      values.due !== undefined && "due",
+      values.priority !== undefined && "priority",
+      values.project !== undefined && "project",
+    ].filter(Boolean),
+  );
+  return titles.map((title) => {
+    const r = readTaskWords(title, {
+      today,
+      people: people.map((name) => ({ id: name, name })),
+      projects,
+      skip,
+    });
+    const read = r.owner || r.due || r.priority || r.project;
+    return read && r.title ? r : { title, owner: null, due: null, priority: null, project: null };
+  });
+}
+
+/** What a title's words said, in a line: "Quinn (@Quinn), due 2026-11-06 (by Friday)". */
+function wordsLine(r) {
+  const bits = [
+    r.owner && `${r.owner.value} (${r.owner.text})`,
+    r.due && `due ${r.due.value} (${r.due.text})`,
+    r.priority && `${r.priority.value} priority (${r.priority.text})`,
+    r.project && `in ${r.project.value} (${r.project.text})`,
+  ].filter(Boolean);
+  return bits.length ? `Read from your words: ${bits.join(", ")}.` : null;
+}
+
 /** --due pilot: the date the owner's queue suggests, set by Harbor. */
 const PILOT = new Set(["pilot", "suggested"]);
 const duePilot = (v) => (v !== undefined && PILOT.has(v.toLowerCase()) ? true : undefined);
@@ -591,7 +653,7 @@ export function hint(message, project) {
           (_, list) => `pick one of ${list.replace(/"/g, "").split("|").join(", ")}`,
         )
         // The CLI reads today, tomorrow and +N before Harbor sees the date.
-        .replace(/^a date as YYYY-MM-DD$/, "a date like 2026-11-30, today, tomorrow, friday or +N days");
+        .replace(/^a date as YYYY-MM-DD$/, "a date like 2026-11-30, today, tomorrow, friday, next friday or +N days");
       if (!seen.has(flag)) seen.set(flag, said);
     }
     return [...seen].map(([flag, why]) => `${flag}: ${why}`).join("\n");
@@ -678,6 +740,12 @@ const DETAIL = {
     "  --project can be left out when the harbor has one open project (First",
     "  voyage aside); the task goes there.",
     "",
+    "  Plain words in a title are read as the website reads them: \"Book the",
+    "  venue @Quinn by friday !high #Website\" adds \"Book the venue\" for",
+    "  Quinn, due Friday, high priority, in Website. Harbor says what it read.",
+    "  A flag wins over the words (they stay in the title), and --literal keeps",
+    "  every title exactly as typed.",
+    "",
     "  --assignee me|none|NAME, --also \"NAME, NAME\" (others on it with the",
     "  owner), --due DATE|pilot, --priority low|medium|high|urgent,",
     "  --status S, --comment TEXT and --over-limit apply to every task added, so",
@@ -2388,12 +2456,10 @@ export async function run(argv, io = {}) {
     case "add": {
       const { positionals, values, harbor } = parse(
         spec(
-          ["over-limit", "dry-run"],
+          ["over-limit", "dry-run", "literal"],
           ["project", "assignee", "also", "due", "priority", "status", "comment"],
         ),
       );
-      // No --project: the harbor's one open project, if that's all there is.
-      if (!values.project) values.project = await onlyProject(client, harbor);
       // Several at once: one title a line on stdin, with no title (or -) after add.
       const piped =
         positionals.length === 0 || (positionals.length === 1 && positionals[0] === "-");
@@ -2411,6 +2477,15 @@ export async function run(argv, io = {}) {
         throw new HarborError(
           "That's more than 100 tasks; harbor import FILE takes a spreadsheet.",
         );
+      // Plain words, as on the website: @person, by Friday, !high, #Project.
+      // --literal keeps every title exactly as typed.
+      const reads = values.literal
+        ? titles.map((title) => ({ title, owner: null, due: null, priority: null, project: null }))
+        : await readTitles(client, harbor, titles, values);
+      // No --project and no #Project: the harbor's one open project, if that's all there is.
+      if (!values.project && !reads.every((r) => r.project))
+        values.project = await onlyProject(client, harbor, "--project NAME or #NAME in the title");
+      const projectOf = (r) => values.project ?? r.project?.value;
       if (values["dry-run"]) {
         const n = titles.length === 1 ? "1 task" : `${titles.length} tasks`;
         // --due pilot: the date each line would take, each counting the ones before it.
@@ -2424,12 +2499,23 @@ export async function run(argv, io = {}) {
               })
             ).dates
           : null;
+        const where = [...new Set(reads.map(projectOf))];
         if (asJson)
           out(
             jsonText({
               dryRun: true,
-              project: values.project,
-              titles,
+              project: where.length === 1 ? where[0] : values.project,
+              titles: reads.map((r) => r.title),
+              ...(reads.some((r) => r.owner || r.due || r.priority || r.project)
+                ? {
+                    read: reads.map((r) => ({
+                      project: projectOf(r),
+                      ...(r.owner ? { assignee: r.owner.value } : {}),
+                      ...(r.due ? { due: r.due.value } : {}),
+                      ...(r.priority ? { priority: r.priority.value } : {}),
+                    })),
+                  }
+                : {}),
               ...(pilot
                 ? { due: pilot.map((d) => d.earliest) }
                 : values.due
@@ -2441,11 +2527,11 @@ export async function run(argv, io = {}) {
           out(
             plain(
               [
-                `Would add ${n} to ${values.project}:`,
-                ...titles.map(
-                  (t, i) =>
-                    `  ${t}${pilot ? `  (due ${pilot[i].earliest})` : values.due ? `  (due ${dueDate(values.due)})` : ""}`,
-                ),
+                `Would add ${n} to ${where.join(" and ")}:`,
+                ...reads.flatMap((r, i) => [
+                  `  ${r.title}${pilot ? `  (due ${pilot[i].earliest})` : values.due ? `  (due ${dueDate(values.due)})` : ""}`,
+                  ...(wordsLine(r) ? [`    ${wordsLine(r)}`] : []),
+                ]),
                 ...(pilot
                   ? [
                       `--due pilot: ${pilot[0].says}; ${pilot[0].why.map((w) => w.charAt(0).toLowerCase() + w.slice(1)).join("; ")}.`,
@@ -2457,25 +2543,25 @@ export async function run(argv, io = {}) {
         return 0;
       }
       const added = [];
-      for (const title of titles) {
+      for (const words of reads) {
         const r = await client
           .call("create_task", {
             harbor,
-            project: values.project,
-            title,
+            project: projectOf(words),
+            title: words.title,
             // Yours unless you say otherwise, as with n in the app.
-            assignee: values.assignee ?? "me",
+            assignee: values.assignee ?? words.owner?.value ?? "me",
             also: values.also === undefined ? undefined : alsoList(values.also),
-            due: duePilot(values.due) ? undefined : dueDate(values.due),
+            due: duePilot(values.due) ? undefined : (dueDate(values.due) ?? words.due?.value),
             suggestedDue: duePilot(values.due),
-            priority: values.priority,
+            priority: values.priority ?? words.priority?.value,
             status: values.status === undefined ? undefined : statusWord(values.status),
             overLimit: values["over-limit"] || undefined,
           })
           .catch((err) => {
             if (err instanceof HarborError) {
               const done = added.length ? ` (added ${added.length} before it)` : "";
-              throw new HarborError(`${hint(err.message, values.project)}${done}`);
+              throw new HarborError(`${hint(err.message, projectOf(words))}${done}`);
             }
             throw err;
           });
@@ -2487,6 +2573,8 @@ export async function run(argv, io = {}) {
               body: values.comment,
             })
           ).commented;
+        const line = wordsLine(words);
+        if (line) r.read = line;
         added.push(r);
       }
       await stalePromptCache(env);
@@ -2500,6 +2588,8 @@ export async function run(argv, io = {}) {
               .map((r) =>
                 [
                   `Added: ${taskLine(r.created, opts)}${r.comment ? ", with your comment" : ""}`,
+                  // What the title's words said, so nothing is read without being seen.
+                  ...(r.read ? [`${r.read} --literal keeps the words in the title.`] : []),
                   // Pilot speaks up only when a date was given that the queue says won't hold.
                   ...(values.due ? pilotLines(r, r.created) : []),
                 ].join("\n"),

package/lib/words.mjs

@@ -0,0 +1,20 @@
+/**
+ * A task in plain words, read the way the website's new task box reads it
+ * ("Book the venue @Quinn by Friday !high #Website"): src/lib/plain-words.ts
+ * itself. A checkout runs that file as it is (Node strips its types); the
+ * published package carries it bundled as dist/words.mjs by build.mjs.
+ */
+async function load() {
+  try {
+    return await import("../../src/lib/plain-words.ts");
+  } catch {
+    return await import("../dist/words.mjs");
+  }
+}
+
+const words = await load();
+
+/** @type {typeof import("../../src/lib/plain-words.ts").readTaskWords} */
+export const readTaskWords = words.readTaskWords;
+/** @type {typeof import("../../src/lib/plain-words.ts").dayFromWords} */
+export const dayFromWords = words.dayFromWords;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@harborppm/cli",
-  "version": "0.76.0",
+  "version": "0.77.0",
   "description": "Harbor from the terminal: a full-screen app with everything, plus commands for scripts and agents.",
   "keywords": [
     "harbor",