@harborppm/cli 0.37.0 → 0.38.0

package/README.md

@@ -151,7 +151,11 @@ harbor issue "TITLE" --project P|--program P [--impact 1-5] [--owner NAME]
 harbor decision "TITLE" --project P|--program P [--owner NAME] [--due DATE]
 harbor risks [words] [--kind risk,issue,decision] [--project P] [--closed]
 harbor brief [--portfolio P] [--say]        the weekly brief, ready to send
-harbor report PROGRAM                       a program's status report
+harbor report PROGRAM                       a program's status report, as Markdown
+harbor export tasks PROJECT|risks|review [--all]
+                                            a spreadsheet (CSV) to stdout
+harbor import FILE [--project P] [--portfolio P] [--no-people]
+                                            add tasks from a CSV file
 harbor premortem PROJECT ["WHAT WENT WRONG"] [--start]
 harbor voyage PROJECT ["YOUR LINE"]
 harbor note PROJECT ["NOTE"] [--opens DATE|--milestone NAME|--off-track]

package/dist/app.mjs

@@ -2772,10 +2772,36 @@ function columnWip(data, projectId, status, extra = 1) {
 	const current = tasksOf(data.tasks, projectId).filter((t) => t.status === status).length;
 	return wipOverflow(col, current, extra);
 }
-var ALL_FIELDS, DEFAULT_DOING_WIP, DEFAULT_REVIEW_WIP;
+var BOARD_PRESETS, ALL_FIELDS, DEFAULT_DOING_WIP, DEFAULT_REVIEW_WIP, WIP_CAP_CHOICES;
 var init_board = __esmMin((() => {
 	init_indexes();
 	init_swatches();
+	BOARD_PRESETS = [
+		{
+			id: "trail",
+			name: "Trail",
+			kicker: "The full walk",
+			blurb: "Backlog through done. Three in play, two in review."
+		},
+		{
+			id: "lean",
+			name: "Lean",
+			kicker: "Just the work",
+			blurb: "To do, in play, done. A cap of three in play."
+		},
+		{
+			id: "delivery",
+			name: "Delivery",
+			kicker: "A review gate",
+			blurb: "In-play and review are capped so work actually finishes."
+		},
+		{
+			id: "intake",
+			name: "Intake",
+			kicker: "Collect, then ship",
+			blurb: "Backlog, to do, done. For paused or sourcing work."
+		}
+	];
 	ALL_FIELDS = {
 		dueDate: true,
 		assignee: true,
@@ -2783,6 +2809,16 @@ var init_board = __esmMin((() => {
 	};
 	DEFAULT_DOING_WIP = 3;
 	DEFAULT_REVIEW_WIP = 2;
+	WIP_CAP_CHOICES = [
+		1,
+		2,
+		3,
+		4,
+		5,
+		8,
+		10,
+		15
+	];
 }));
 
 //#endregion
@@ -7169,7 +7205,7 @@ const HELP = [
 	["↑↓ or j k", "move; ←→ or h l across columns and lists"],
 	["Enter / Esc", "open / back"],
 	["n", "new: a task, or what the screen lists"],
-	["e", "change what's open (health, lead, dates)"],
+	["e / b", "change what's open / a project's board setup"],
 	["[ ] / { }", "move a card a column / a project along its hill"],
 	["x / d", "mark done / delete (asks first)"],
 	["u / r", "undo your last change / retry saving"],
@@ -9279,6 +9315,7 @@ function ProjectView({ projectId, active, width, height, go, onBack }) {
 		if (key.escape || key.backspace) return onBack();
 		if (input === "v") return setMode((m) => m === "board" ? "list" : m === "list" ? "budget" : "board");
 		if (input === "e") return go.openPanel("project", projectId);
+		if (input === "b") return go.openPanel("board", projectId);
 		if (input === "R") return go.create("raid", { projectId });
 		if (input === "f" && mode !== "budget") return go.pick("Show cards assigned to", [
 			{
@@ -9419,7 +9456,7 @@ function ProjectView({ projectId, active, width, height, go, onBack }) {
 								]
 							}) : null,
 							" ",
-							"· v next · f p filter · e details"
+							"· v next · f p filter · e details · b setup"
 						]
 					})
 				})]
@@ -9799,6 +9836,435 @@ function RoadmapView({ active, width, height, go }) {
 	});
 }
 
+//#endregion
+//#region src/lib/automation-text.ts
+init_swatches();
+const TRIGGER_LABEL = {
+	task_created: "A task is created",
+	status_changed_to: "Status is set to…",
+	priority_changed_to: "Priority is set to…",
+	assigned: "A task is assigned to anyone"
+};
+const ACTION_LABEL = {
+	set_status: "Set status to…",
+	set_priority: "Set priority to…",
+	set_assignee: "Assign to…",
+	add_comment: "Post a comment"
+};
+function describeAction(a, peopleName) {
+	switch (a.type) {
+		case "set_status": return `set status to ${a.status ? TASK_STATUS_LABEL[a.status] : "…"}`;
+		case "set_priority": return `set priority to ${a.priority ? PRIORITY_LABEL[a.priority] : "…"}`;
+		case "set_assignee": return `assign to ${peopleName(a.assigneeId)}`;
+		case "add_comment": return `post “${a.commentBody ?? ""}”`;
+	}
+}
+function describeTrigger(rule) {
+	const t = rule.trigger;
+	if (t.type === "status_changed_to") return `When status is set to ${t.status ? TASK_STATUS_LABEL[t.status] : "…"}`;
+	if (t.type === "priority_changed_to") return `When priority is set to ${t.priority ? PRIORITY_LABEL[t.priority] : "…"}`;
+	return `When ${TRIGGER_LABEL[t.type].toLowerCase()}`;
+}
+/** "When status is set to Done: set priority to Low, post “Shipped”". */
+function describeRule(rule, peopleName) {
+	const did = rule.actions.map((a) => describeAction(a, peopleName)).join(", ");
+	return `${describeTrigger(rule)}: ${did || "no actions"}`;
+}
+function defaultAction(type) {
+	if (type === "set_status") return {
+		type,
+		status: "done"
+	};
+	if (type === "set_priority") return {
+		type,
+		priority: "high"
+	};
+	if (type === "set_assignee") return {
+		type,
+		assigneeId: null
+	};
+	return {
+		type,
+		commentBody: ""
+	};
+}
+
+//#endregion
+//#region src/lib/custom-field-text.ts
+const FIELD_TYPE_LABEL = {
+	text: "Text",
+	number: "Number",
+	select: "Dropdown",
+	checkbox: "Checkbox"
+};
+const FIELD_TYPES = Object.keys(FIELD_TYPE_LABEL);
+/** A dropdown's options from "S, M, L". */
+function optionsOf(value) {
+	return value.split(",").map((o) => o.trim()).filter(Boolean);
+}
+/** A task's value for a field as one line: "" when it has none. */
+function fieldValueText(def, value) {
+	if (value == null || value === "") return "";
+	if (def.type === "checkbox") return value ? "Yes" : "";
+	return String(value);
+}
+/** What someone typed for a text or number field; undefined when a number can't be read. */
+function readFieldValue(def, text) {
+	const t = text.trim();
+	if (!t) return null;
+	if (def.type !== "number") return t;
+	const n = Number(t.replace(/,/g, ""));
+	return Number.isFinite(n) ? n : void 0;
+}
+
+//#endregion
+//#region src/tui/views/setup.tsx
+/**
+* A project's board setup, as the website's board settings have it: where it
+* starts from, each column (name, shown, cap, place), lanes and what cards
+* show, the project's own fields and its automations. b on a project opens it.
+*/
+init_board();
+init_swatches();
+const LANES = [
+	{
+		value: "none",
+		label: "None"
+	},
+	{
+		value: "assignee",
+		label: "By person"
+	},
+	{
+		value: "priority",
+		label: "By priority"
+	}
+];
+const CARD_FIELDS = [
+	{
+		key: "dueDate",
+		label: "Due date"
+	},
+	{
+		key: "assignee",
+		label: "Owner"
+	},
+	{
+		key: "priority",
+		label: "Priority"
+	}
+];
+const statusChoices = () => TASK_COLUMNS.map((s) => ({
+	label: TASK_STATUS_LABEL[s],
+	value: s
+}));
+const priorityChoices = () => PRIORITIES$1.map((p) => ({
+	label: PRIORITY_LABEL[p],
+	value: p
+}));
+function presetName(id) {
+	return BOARD_PRESETS.find((p) => p.id === id)?.name ?? "Your own";
+}
+function columnValue(c) {
+	const bits = [columnLabel(c)];
+	if (!c.visible) bits.push("hidden");
+	bits.push(c.wipLimit == null ? "no cap" : `cap ${c.wipLimit}`);
+	return bits.join(" · ");
+}
+function fieldValue(f) {
+	const kind = FIELD_TYPE_LABEL[f.type];
+	return f.type === "select" && f.options?.length ? `${kind}: ${f.options.join(", ")}` : kind;
+}
+function BoardPanel({ id, width, height, go, active, onClose }) {
+	const { store } = useDeps();
+	const project = useHarbor((s) => s.projects.find((p) => p.id === id));
+	const boardConfigs = useHarbor((s) => s.boardConfigs);
+	const people = useHarbor((s) => s.people);
+	if (!project) return null;
+	const config = boardConfigOf({ boardConfigs }, id);
+	const set = (patch) => store.getState().setBoardConfig(id, {
+		...config,
+		preset: "custom",
+		...patch
+	});
+	const setColumns = (columns) => set({ columns });
+	const peopleName = (pid) => pid ? people.find((p) => p.id === pid)?.name ?? "someone no longer here" : "no one";
+	const columnField = (c, i) => ({
+		label: TASK_STATUS_LABEL[c.status],
+		value: columnValue(c),
+		edit: {
+			kind: "pick",
+			title: `The ${columnLabel(c)} column`,
+			choices: [
+				{
+					label: "Rename it",
+					value: "rename"
+				},
+				{
+					label: c.visible ? "Hide it" : "Show it",
+					value: "visible"
+				},
+				{
+					label: "Change its cap",
+					value: "cap"
+				},
+				...i > 0 ? [{
+					label: "Move it left",
+					value: "left"
+				}] : [],
+				...i < config.columns.length - 1 ? [{
+					label: "Move it right",
+					value: "right"
+				}] : []
+			],
+			onPick: (what) => {
+				const others = config.columns;
+				const put = (next) => setColumns(others.map((x) => x.status === c.status ? next : x));
+				if (what === "rename") return go.ask(`Name for ${TASK_STATUS_LABEL[c.status]}`, (text) => put({
+					...c,
+					label: text.trim() || TASK_STATUS_LABEL[c.status]
+				}), columnLabel(c));
+				if (what === "visible") {
+					if (c.visible && others.filter((x) => x.visible).length === 1) return go.notify("A board shows at least one column.");
+					return put({
+						...c,
+						visible: !c.visible
+					});
+				}
+				if (what === "cap") return go.pick(`Cap for ${columnLabel(c)}`, [{
+					label: "No cap",
+					value: null
+				}, ...WIP_CAP_CHOICES.map((n) => ({
+					label: String(n),
+					value: n
+				}))], (n) => put(withWipLimit(c, n)));
+				const to = i + (what === "left" ? -1 : 1);
+				const next = others.slice();
+				[next[i], next[to]] = [next[to], next[i]];
+				setColumns(next);
+			}
+		}
+	});
+	const fields = [
+		{
+			label: "Starts from",
+			value: presetName(config.preset),
+			edit: {
+				kind: "pick",
+				title: "Start the board from (its columns and caps are replaced; u undoes it)",
+				choices: BOARD_PRESETS.map((p) => ({
+					label: p.name,
+					value: p.id,
+					hint: p.blurb
+				})),
+				initial: Math.max(0, BOARD_PRESETS.findIndex((p) => p.id === config.preset)),
+				onPick: (v) => store.getState().applyBoardPreset(id, v)
+			}
+		},
+		...config.columns.map(columnField),
+		{
+			label: "Lanes",
+			value: LANES.find((l) => l.value === config.swimlane)?.label ?? "None",
+			edit: {
+				kind: "pick",
+				title: "Lanes across the website's board",
+				choices: LANES.map((l) => ({
+					label: l.label,
+					value: l.value
+				})),
+				initial: LANES.findIndex((l) => l.value === config.swimlane),
+				onPick: (v) => set({ swimlane: v })
+			}
+		},
+		{
+			label: "Cards show",
+			value: CARD_FIELDS.filter((f) => config.cardFields[f.key]).map((f) => f.label.toLowerCase()).join(", ") || "just the title",
+			edit: {
+				kind: "pick",
+				title: "Show or hide on the website's cards",
+				choices: CARD_FIELDS.map((f) => ({
+					label: `${config.cardFields[f.key] ? "Hide" : "Show"} ${f.label.toLowerCase()}`,
+					value: f.key
+				})),
+				onPick: (k) => {
+					const key = k;
+					set({ cardFields: {
+						...config.cardFields,
+						[key]: !config.cardFields[key]
+					} });
+				}
+			}
+		},
+		{
+			label: "Compact cards",
+			value: config.compactCards ? "Yes" : "No",
+			edit: {
+				kind: "pick",
+				choices: [{
+					label: "Yes",
+					value: true
+				}, {
+					label: "No",
+					value: false
+				}],
+				initial: config.compactCards ? 0 : 1,
+				onPick: (v) => set({ compactCards: v })
+			}
+		},
+		...(project.customFields ?? []).map((f) => ({
+			label: `Field “${f.name}”`,
+			value: fieldValue(f),
+			edit: {
+				kind: "pick",
+				title: `The field “${f.name}”`,
+				choices: [
+					{
+						label: "Rename it",
+						value: "rename"
+					},
+					...f.type === "select" ? [{
+						label: "Change its options",
+						value: "options"
+					}] : [],
+					{
+						label: "Take it out",
+						value: "remove"
+					}
+				],
+				onPick: (what) => {
+					const s = store.getState();
+					if (what === "rename") return go.ask("Field name", (text) => text.trim() && s.updateCustomField(id, f.id, { name: text.trim() }), f.name);
+					if (what === "options") return go.ask("Options, split by commas", (text) => s.updateCustomField(id, f.id, { options: optionsOf(text) }), (f.options ?? []).join(", "));
+					go.confirm(`Take out the field “${f.name}” and every task's value for it? u undoes it.`, () => s.removeCustomField(id, f.id), "Take it out");
+				}
+			}
+		})),
+		{
+			label: "Add a field",
+			value: (project.customFields ?? []).length ? "" : "Tasks here have no fields of their own yet",
+			edit: {
+				kind: "text",
+				initial: "",
+				placeholder: "A name, like Size or Customer",
+				onSave: (name) => {
+					const trimmed = name.trim();
+					if (!trimmed) return;
+					go.pick(`What “${trimmed}” holds`, FIELD_TYPES.map((t) => ({
+						label: FIELD_TYPE_LABEL[t],
+						value: t
+					})), (t) => {
+						const type = t;
+						if (type !== "select") return void store.getState().addCustomField(id, {
+							name: trimmed,
+							type
+						});
+						go.ask("Options, split by commas", (text) => {
+							store.getState().addCustomField(id, {
+								name: trimmed,
+								type,
+								options: optionsOf(text)
+							});
+						});
+					});
+				}
+			}
+		},
+		...(project.automations ?? []).map((r, n) => ({
+			label: `Automation ${n + 1}`,
+			value: `${describeRule(r, peopleName)}${r.enabled ? "" : " (off)"}`,
+			edit: {
+				kind: "pick",
+				title: describeTrigger(r),
+				choices: [{
+					label: r.enabled ? "Turn it off" : "Turn it on",
+					value: "toggle"
+				}, {
+					label: "Take it out",
+					value: "remove"
+				}],
+				onPick: (what) => {
+					const s = store.getState();
+					if (what === "toggle") return s.updateAutomation(id, r.id, { enabled: !r.enabled });
+					go.confirm("Take out this automation? u undoes it.", () => s.removeAutomation(id, r.id), "Take it out");
+				}
+			}
+		})),
+		{
+			label: "Add an automation",
+			value: (project.automations ?? []).length ? "" : "When something happens, do something",
+			edit: {
+				kind: "pick",
+				title: "When",
+				choices: Object.keys(TRIGGER_LABEL).map((t) => ({
+					label: TRIGGER_LABEL[t],
+					value: t
+				})),
+				onPick: (t) => askTrigger(t)
+			}
+		}
+	];
+	function askTrigger(type) {
+		if (type === "status_changed_to") return go.pick("When status is set to", statusChoices(), (s) => askAction({
+			type,
+			status: s
+		}));
+		if (type === "priority_changed_to") return go.pick("When priority is set to", priorityChoices(), (p) => askAction({
+			type,
+			priority: p
+		}));
+		askAction({ type });
+	}
+	function askAction(trigger) {
+		go.pick(`${describeTrigger({ trigger })}, then`, Object.keys(ACTION_LABEL).map((a) => ({
+			label: ACTION_LABEL[a],
+			value: a
+		})), (a) => {
+			const type = a;
+			const add = (action) => store.getState().addAutomation(id, {
+				name: describeTrigger({ trigger }),
+				enabled: true,
+				trigger,
+				actions: [action]
+			});
+			if (type === "set_status") return go.pick("Set status to", statusChoices(), (s) => add({
+				type,
+				status: s
+			}));
+			if (type === "set_priority") return go.pick("Set priority to", priorityChoices(), (p) => add({
+				type,
+				priority: p
+			}));
+			if (type === "set_assignee") return go.pick("Assign to", [{
+				label: "Nobody",
+				value: null
+			}, ...people.map((p) => ({
+				label: p.name,
+				value: p.id,
+				hint: p.role
+			}))], (pid) => add({
+				...defaultAction(type),
+				assigneeId: pid
+			}));
+			go.ask("Comment to post", (text) => text.trim() && add({
+				type,
+				commentBody: text.trim()
+			}));
+		});
+	}
+	return /* @__PURE__ */ jsx(DetailPanel, {
+		title: /* @__PURE__ */ jsx(Text, {
+			bold: true,
+			children: project.name
+		}),
+		subtitle: "Board setup · lanes and card options show on the website's board",
+		fields,
+		width,
+		height,
+		active,
+		onClose
+	});
+}
+
 //#endregion
 //#region src/lib/recurrence.ts
 /** The due date one interval after `from`. */
@@ -9909,7 +10375,9 @@ function TaskPanel({ taskId, width, height, go, active = true, onClose }) {
 	const task = tasks.find((t) => t.id === taskId);
 	const [at, setAt] = useState(0);
 	const [editing, setEditing] = useState(null);
-	const rows = FIELDS$1.length + (task?.checklist.length ?? 0);
+	const own = projects.find((p) => p.id === task?.projectId)?.customFields ?? [];
+	const stepsFrom = FIELDS$1.length + own.length;
+	const rows = stepsFrom + (task?.checklist.length ?? 0);
 	const day = today();
 	useInput((input, key) => {
 		if (!task) return onClose();
@@ -9927,7 +10395,9 @@ function TaskPanel({ taskId, width, height, go, active = true, onClose }) {
 			store.getState().deleteTask(task.id);
 			onClose();
 		}, "Delete");
-		const item = task.checklist[at - FIELDS$1.length];
+		const custom = own[at - FIELDS$1.length];
+		if (custom && key.return) return editCustom(custom);
+		const item = task.checklist[at - stepsFrom];
 		if (item && (input === " " || key.return)) return store.getState().toggleChecklistItem(task.id, item.id);
 		if (item && input === "-") return store.getState().removeChecklistItem(task.id, item.id);
 		if (key.return && FIELDS$1[at]) return setEditing({
@@ -9943,6 +10413,23 @@ function TaskPanel({ taskId, width, height, go, active = true, onClose }) {
 	const mine = comments.filter((c) => c.taskId === task.id && c.authorId === me);
 	const blockers = blockersOf(task, tasks);
 	const done = () => setEditing(null);
+	const setCustom = (fieldId, value) => store.getState().setTaskCustomFieldValue(task.id, fieldId, value);
+	function editCustom(f) {
+		if (!task) return;
+		const value = task.customFieldValues?.[f.id] ?? null;
+		if (f.type === "checkbox") return setCustom(f.id, !value);
+		if (f.type === "select") return go.pick(f.name, [{
+			label: "None",
+			value: null
+		}, ...(f.options ?? []).map((o) => ({
+			label: o,
+			value: o
+		}))], (v) => setCustom(f.id, v));
+		setEditing({
+			kind: "custom",
+			fieldId: f.id
+		});
+	}
 	const value = {
 		title: task.title,
 		status: STATUS_LABEL[task.status],
@@ -10009,6 +10496,17 @@ function TaskPanel({ taskId, width, height, go, active = true, onClose }) {
 				done();
 			}
 		});
+	} else if (editing?.kind === "custom") {
+		const f = own.find((x) => x.id === editing.fieldId);
+		if (f) editor = /* @__PURE__ */ jsx(CustomField, {
+			def: f,
+			initial: fieldValueText(f, task.customFieldValues?.[f.id]),
+			onCancel: done,
+			onSubmit: (v) => {
+				setCustom(f.id, v);
+				done();
+			}
+		});
 	} else if (editing?.kind === "field") {
 		const f = editing.field;
 		if (f === "title" || f === "notes") editor = /* @__PURE__ */ jsx(TextField, {
@@ -10153,6 +10651,22 @@ function TaskPanel({ taskId, width, height, go, active = true, onClose }) {
 					value[f.field]
 				]
 			}, f.field)),
+			own.map((f, n) => {
+				const on = at === FIELDS$1.length + n;
+				return /* @__PURE__ */ jsxs(Text, {
+					wrap: "truncate-end",
+					color: on ? theme.selected : void 0,
+					bold: on,
+					children: [
+						on ? "› " : "  ",
+						/* @__PURE__ */ jsx(Text, {
+							color: theme.muted,
+							children: f.name.slice(0, 8).padEnd(9)
+						}),
+						fieldValueText(f, task.customFieldValues?.[f.id]) || "—"
+					]
+				}, f.id);
+			}),
 			waits.length > 0 ? /* @__PURE__ */ jsxs(Text, {
 				color: theme.warn,
 				wrap: "truncate-end",
@@ -10172,7 +10686,7 @@ function TaskPanel({ taskId, width, height, go, active = true, onClose }) {
 				]
 			}),
 			task.checklist.map((item, i) => {
-				const on = at === FIELDS$1.length + i;
+				const on = at === stepsFrom + i;
 				return /* @__PURE__ */ jsxs(Text, {
 					color: on ? theme.selected : void 0,
 					bold: on,
@@ -10232,6 +10746,21 @@ function TaskPanel({ taskId, width, height, go, active = true, onClose }) {
 		]
 	});
 }
+/** A text or number field of the project's own; a number that can't be read says so. */
+function CustomField({ def, initial, onSubmit, onCancel }) {
+	const [error, setError] = useState(null);
+	return /* @__PURE__ */ jsx(TextField, {
+		label: def.name,
+		initial,
+		hint: error ?? (def.type === "number" ? "A number, or empty for none" : "Empty for none"),
+		onCancel,
+		onSubmit: (text) => {
+			const v = readFieldValue(def, text);
+			if (v === void 0) return setError(`“${text}” isn't a number.`);
+			onSubmit(v);
+		}
+	});
+}
 function DueField({ initial, today, onSubmit, onCancel }) {
 	const [error, setError] = useState(null);
 	return /* @__PURE__ */ jsx(Box, {
@@ -10941,6 +11470,10 @@ function App({ ui }) {
 		id: panel.id,
 		...panelProps
 	});
+	else if (panel?.kind === "board") panelNode = /* @__PURE__ */ jsx(BoardPanel, {
+		id: panel.id,
+		...panelProps
+	});
 	else if (panel?.kind === "milestone") panelNode = /* @__PURE__ */ jsx(MilestonePanel, {
 		id: panel.id,
 		...panelProps

package/lib/cli.mjs

@@ -17,6 +17,8 @@ import {
   writeSettings,
 } from "./config.mjs";
 import {
+  forecastData,
+  importText,
   forecastList,
   forecastOne,
   STATUS,
@@ -122,6 +124,10 @@ export const HELP = `harbor: Harbor from the terminal
                                               --say reads it aloud as a
                                               shipping forecast
   harbor report PROGRAM                       a program's status report
+  harbor export tasks PROJECT|risks|review [--all]
+                                              a spreadsheet (CSV) to stdout
+  harbor import FILE [--project P] [--portfolio P] [--no-people]
+                                              add tasks from a CSV file
   harbor premortem PROJECT ["WHAT WENT WRONG"] [--start]
                                               a project's pre-mortem: start,
                                               answer or read it
@@ -444,6 +450,45 @@ const DETAIL = {
     "  PROJECT is a name, a key like RR, or an id. When two projects share a",
     "  name, give the key.",
   ],
+  forecast: [
+    "  harbor forecast [--program P]          reads when each open project will",
+    "                                         likely finish",
+    "  harbor forecast PROJECT                reads one project's forecast and what",
+    "                                         it rests on",
+    "",
+    "  Worked out from the crew's pace alone: how many tasks they finished each",
+    "  week over the last six (or the project's life, if shorter), replayed a",
+    "  thousand times until its open tasks run out. Probably is half of those",
+    "  runs, very likely 85%, almost certainly 95%. No estimates or points.",
+    "  It warns when under two weeks of pace is all there is, and when an open",
+    "  task is due after the likely finish, since the pace can't see due dates.",
+  ],
+  report: [
+    "  harbor report PROGRAM                  reads the program's status report",
+    "",
+    "  Prints Markdown, as the website's Status report button writes it:",
+    "  health, progress, late work, milestones, risks and the next move.",
+    "  Ready to paste; harbor report PROGRAM > report.md saves it.",
+  ],
+  export: [
+    "  harbor export tasks PROJECT            reads a project's tasks as CSV",
+    "  harbor export risks [--all]            reads the risk register as CSV",
+    "                                         (--all adds closed ones)",
+    "  harbor export review                   reads the review as CSV",
+    "",
+    "  The same spreadsheets the website's Export buttons download. They print;",
+    "  harbor export tasks RR > tasks.csv saves one.",
+  ],
+  import: [
+    "  harbor import FILE --project P         writes: adds the file's tasks",
+    "  harbor import FILE --portfolio P       writes: makes projects as the file",
+    "                                         names them",
+    "",
+    "  FILE is CSV or tab-separated: a spreadsheet, or a Jira, Asana or Linear",
+    "  export. It needs a column of titles; rows naming a Project column go",
+    "  there. People it names who aren't in the harbor are added unless you say",
+    "  --no-people. A task already in its project by title is left alone.",
+  ],
   note: [
     "  harbor note PROJECT                    reads its notes for later: who left",
     "                                         each, what opens it, and the opened ones",
@@ -507,6 +552,21 @@ const DETAIL = {
     "  PROJECT is a name, a key like RR, or an id. When two projects share a",
     "  name, give the key.",
   ],
+  risk: [
+    '  harbor risk "TITLE" --project P        writes: logs a risk on the project',
+    '  harbor risk "TITLE" --program P        writes: logs one on the program',
+    "      [--impact 1-5] [--probability 1-5] [--owner NAME] [--due DATE]",
+  ],
+  issue: [
+    '  harbor issue "TITLE" --project P       writes: logs an issue on the project',
+    '  harbor issue "TITLE" --program P       writes: logs one on the program',
+    "      [--impact 1-5] [--owner NAME] [--due DATE]",
+  ],
+  decision: [
+    '  harbor decision "TITLE" --project P    writes: logs a decision to make',
+    '  harbor decision "TITLE" --program P    writes: logs one on the program',
+    "      [--owner NAME] [--due DATE] (the date to decide by)",
+  ],
 };
 
 /** The lines of the help about one command, or null when it has none. */
@@ -1094,8 +1154,21 @@ export async function run(argv, io = {}) {
     case "forecast": {
       const { positionals, values, harbor } = parse(spec([], ["program"]));
       const project = positionals.join(" ").trim();
-      if (project) return call("get_project", { harbor, project }, forecastOne);
-      return call("list_projects", { harbor, program: values.program, limit: 100 }, forecastList);
+      // --json gets each forecast flat beside the project's name (forecastData).
+      const withFinish = (p) => ({ ...p, finish: p });
+      if (project)
+        return call(
+          "get_project",
+          { harbor, project },
+          (d) => forecastOne(withFinish(d)),
+          forecastData,
+        );
+      return call(
+        "list_projects",
+        { harbor, program: values.program, limit: 100 },
+        (d) => forecastList({ projects: d.projects.map(withFinish) }),
+        forecastData,
+      );
     }
     case "hill": {
       const { positionals, values, harbor } = parse(spec([], ["program", "at"]));
@@ -1475,6 +1548,44 @@ export async function run(argv, io = {}) {
       if (!program) throw new HarborError('Give a program: harbor report "NAME".');
       return call("status_report", { harbor, program }, (r) => r.markdown);
     }
+    case "export": {
+      const { positionals, values, harbor } = parse(spec(["all"]));
+      const [what, ...name] = positionals;
+      if (!["tasks", "risks", "review"].includes(what))
+        throw new HarborError("Say what to export: harbor export tasks PROJECT, risks or review.");
+      const project = name.join(" ").trim();
+      if (what === "tasks" && !project)
+        throw new HarborError('Give the project: harbor export tasks "NAME".');
+      if (what !== "tasks") none(name);
+      return call(
+        "export_csv",
+        { harbor, what, project: project || undefined, all: Boolean(values.all) },
+        (r) => r.csv.replace(/\r\n/g, "\n"),
+      );
+    }
+    case "import": {
+      const { positionals, values, harbor } = parse(spec(["no-people"], ["project", "portfolio"]));
+      const [file, ...extra] = positionals;
+      if (!file) throw new HarborError("Give the file: harbor import tasks.csv --project NAME.");
+      none(extra);
+      let csv;
+      try {
+        csv = readFileSync(file, "utf8");
+      } catch {
+        throw new HarborError(`Can't read ${file}.`);
+      }
+      return call(
+        "import_tasks",
+        {
+          harbor,
+          csv,
+          project: values.project,
+          portfolio: values.portfolio,
+          addPeople: !values["no-people"],
+        },
+        importText,
+      );
+    }
     case "premortem": {
       const { positionals, values, harbor } = parse(spec(["start"]));
       const [project, ...words] = positionals;

package/lib/format.mjs

@@ -216,9 +216,32 @@ function chance(c) {
   return `${Math.round(c * 20) * 5}%`;
 }
 
+/**
+ * The forecast's dates as phrases, a date said once: when half and 85% of
+ * runs finish the same day, "very likely by" it is. At most `most` of them.
+ */
+function finishPhrases(f, most = 3) {
+  const steps = [
+    [f.likely, "probably"],
+    [f.veryLikely, "very likely by"],
+    [f.almostCertain, "almost certainly by"],
+  ].filter(([date]) => date);
+  const kept = steps.filter(([date], i) => date !== steps[i + 1]?.[0]);
+  return kept.slice(0, most).map(([date, words]) => `${words} ${date}`);
+}
+
 function finishRange(f) {
   if (!f.likely) return "not in the next two years at this pace";
-  return `probably ${f.likely}${f.veryLikely ? `, very likely by ${f.veryLikely}` : ""}`;
+  return finishPhrases(f, 2).join(", ");
+}
+
+/** What the pace can't see, as short notes for the list. */
+function finishNotes(f) {
+  return [
+    f.rough ? "rough" : null,
+    f.shortHistory ? "under 2 weeks of pace" : null,
+    f.lastDue ? `${f.lastDue.key ?? `“${f.lastDue.title}”`} due ${f.lastDue.due}` : null,
+  ].filter(Boolean);
 }
 
 /** When each open project will likely finish at its crew's recent pace. */
@@ -232,7 +255,7 @@ export function forecastList(r) {
       const name = p.name.length > width ? `${p.name.slice(0, width - 1)}…` : p.name.padEnd(width);
       if (f.none) return `${name}  no forecast: ${f.none.replace(/^\w/, (c) => c.toLowerCase())}`;
       const end = p.ends ? ` · ${chance(f.chanceByEnd)} by its end, ${p.ends}` : "";
-      return `${name}  ${finishRange(f)}${end}${f.rough ? " · rough" : ""}`;
+      return [`${name}  ${finishRange(f)}${end}`, ...finishNotes(f)].join(" · ");
     })
     .join("\n");
 }
@@ -241,10 +264,10 @@ export function forecastList(r) {
 export function forecastOne(p) {
   const f = p.finish ?? {};
   if (f.none) return `${p.name}: ${f.none}`;
-  const range = finishRange(f);
+  const [first, ...more] = finishPhrases(f);
   const lines = [
     f.likely
-      ? `${p.name} will ${range.replace(/^probably/, "probably finish")}${f.almostCertain ? `, almost certainly by ${f.almostCertain}` : ""}.`
+      ? `${p.name} will ${first.replace(/^(probably|very likely|almost certainly)/, "$1 finish")}${more.map((x) => `, ${x}`).join("")}.`
       : `${p.name} won't finish in the next two years at this pace.`,
   ];
   if (p.ends) {
@@ -255,9 +278,33 @@ export function forecastOne(p) {
     `${f.openTasks} task${f.openTasks === 1 ? "" : "s"} open; the crew finishes about ${f.finishedPerWeek} a week (${f.basedOn}).`,
   );
   if (f.rough) lines.push("Only a few tasks have finished, so treat this as rough.");
+  if (f.shortHistory)
+    lines.push(
+      "That pace comes from under two weeks of work; tasks logged as done in a batch make it look faster than it is.",
+    );
+  if (f.lastDue) {
+    const which = f.lastDue.key ? `${f.lastDue.key} “${f.lastDue.title}”` : `“${f.lastDue.title}”`;
+    lines.push(
+      `${which} is due ${f.lastDue.due}, after the likely finish, so the plan runs longer than the pace says.`,
+    );
+  }
   return lines.join("\n");
 }
 
+/** forecast --json: the finish forecast itself, with only what names the project around it. */
+export function forecastData(r) {
+  const one = (p) => ({
+    id: p.id,
+    name: p.name,
+    ...(p.key ? { key: p.key } : {}),
+    ...(p.program !== undefined ? { program: p.program } : {}),
+    ends: p.ends ?? null,
+    ...p.finish,
+  });
+  if (!r.projects) return one(r);
+  return { projects: r.projects.filter((p) => p.health !== "done").map(one) };
+}
+
 /** A project's pre-mortem, as get_premortem answers it. */
 export function premortemText(r) {
   if (!r.running) {
@@ -370,6 +417,25 @@ export function hillList(r) {
   return blocks.join("\n\n");
 }
 
+/** What harbor import did, as import_tasks answers it. */
+export function importText(r) {
+  const n = (count, word) => `${count} ${word}${count === 1 ? "" : "s"}`;
+  const from = r.from ? ` from ${r.from}` : "";
+  const lines = [
+    r.imported
+      ? `Imported ${n(r.imported, "task")}${from} into ${r.portfolio}.`
+      : `Nothing imported${from}.`,
+  ];
+  if (r.newPrograms?.length) lines.push(`New programs: ${r.newPrograms.join(", ")}.`);
+  if (r.newProjects?.length) lines.push(`New projects: ${r.newProjects.join(", ")}.`);
+  if (r.newPeople?.length) lines.push(`New people: ${r.newPeople.join(", ")}.`);
+  if (r.alreadyThere) lines.push(`${n(r.alreadyThere, "task")} already there, left alone.`);
+  if (r.leftOut) lines.push(`${n(r.leftOut, "row")} left out (canceled, won't do or duplicate).`);
+  if (r.waitsOnLinks) lines.push(`${n(r.waitsOnLinks, "link")} between tasks became "waits on".`);
+  for (const p of r.problems ?? []) lines.push(`Row ${p.row}: ${p.message}`);
+  return lines.join("\n");
+}
+
 /** A project's notes for later, as get_project lists them. */
 export function notesText(project, notes) {
   if (!notes?.length)

package/package.json

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