@mulmoclaude/todo-plugin 0.1.0

package/dist/index.js

@@ -0,0 +1,1223 @@
+import { t as TOOL_DEFINITION } from "./definition-mymex4HE.js";
+import { a as listLabelsWithCount, c as subtractLabels, o as mergeLabels, r as filterByLabels } from "./labels-C4z7FMoE.js";
+//#region ../../../node_modules/gui-chat-protocol/dist/index.js
+function definePlugin(setup) {
+	return setup;
+}
+//#endregion
+//#region src/internal/utils.ts
+function makeId(prefix) {
+	return `${prefix}_${globalThis.crypto.randomUUID()}`;
+}
+function isRecord(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+var MAX_SLUG_LEN = 60;
+function slugify$1(label, fallback) {
+	const normalised = label.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, MAX_SLUG_LEN);
+	return normalised.length > 0 ? normalised : fallback;
+}
+function disambiguateSlug(base, existingIds) {
+	if (!existingIds.has(base)) return base;
+	let n = 2;
+	while (existingIds.has(`${base}-${n}`)) n += 1;
+	return `${base}-${n}`;
+}
+//#endregion
+//#region src/handlers/columns.ts
+var DEFAULT_COLUMNS = [
+	{
+		id: "backlog",
+		label: "Backlog"
+	},
+	{
+		id: "todo",
+		label: "Todo"
+	},
+	{
+		id: "in-progress",
+		label: "In Progress"
+	},
+	{
+		id: "done",
+		label: "Done",
+		isDone: true
+	}
+];
+function slugify(label) {
+	return slugify$1(label, "column");
+}
+function uniqueId(base, existingIds) {
+	return disambiguateSlug(base, existingIds);
+}
+function findColumn(columns, columnId) {
+	return columns.find((column) => column.id === columnId);
+}
+function ensureColumnsValid(columns) {
+	if (columns.length === 0) return [...DEFAULT_COLUMNS];
+	const seen = /* @__PURE__ */ new Set();
+	for (const column of columns) {
+		if (seen.has(column.id)) return [...DEFAULT_COLUMNS];
+		seen.add(column.id);
+	}
+	const doneCount = columns.filter((column) => column.isDone).length;
+	if (doneCount === 0) return columns.map((column, i) => i === columns.length - 1 ? {
+		...column,
+		isDone: true
+	} : column);
+	if (doneCount > 1) {
+		let kept = false;
+		return columns.map((column) => {
+			if (!column.isDone) return column;
+			if (kept) return {
+				id: column.id,
+				label: column.label
+			};
+			kept = true;
+			return column;
+		});
+	}
+	return columns;
+}
+function normalizeColumns(raw) {
+	if (!Array.isArray(raw)) return [...DEFAULT_COLUMNS];
+	const cleaned = [];
+	for (const entry of raw) {
+		if (!isRecord(entry)) continue;
+		if (typeof entry["id"] !== "string" || typeof entry["label"] !== "string") continue;
+		const col = {
+			id: entry["id"],
+			label: entry["label"]
+		};
+		if (entry["isDone"] === true) col.isDone = true;
+		cleaned.push(col);
+	}
+	return ensureColumnsValid(cleaned);
+}
+function doneColumnId(columns) {
+	const done = columns.find((column) => column.isDone);
+	if (done) return done.id;
+	const last = columns[columns.length - 1];
+	if (!last) throw new Error("doneColumnId: empty columns array (normalizeColumns invariant violated)");
+	return last.id;
+}
+function defaultStatusId(columns) {
+	const open = columns.find((column) => !column.isDone);
+	return open ? open.id : doneColumnId(columns);
+}
+function resyncDoneMembership(items, newDoneId) {
+	let changed = false;
+	return {
+		items: items.map((item) => {
+			const shouldBeDone = item.status === newDoneId;
+			if (item.completed === shouldBeDone) return item;
+			changed = true;
+			return {
+				...item,
+				completed: shouldBeDone
+			};
+		}),
+		changed
+	};
+}
+var ORDER_STEP$1 = 1e3;
+function rebuildColumnOrder(items, columnId) {
+	const inColumn = items.filter((item) => item.status === columnId).sort((left, right) => (left.order ?? 0) - (right.order ?? 0));
+	const newOrders = /* @__PURE__ */ new Map();
+	inColumn.forEach((item, index) => newOrders.set(item.id, (index + 1) * ORDER_STEP$1));
+	return items.map((item) => {
+		const newOrder = newOrders.get(item.id);
+		if (newOrder === void 0) return item;
+		return {
+			...item,
+			order: newOrder
+		};
+	});
+}
+function handleAddColumn(columns, items, input) {
+	if (!input.label || input.label.trim().length === 0) return {
+		kind: "error",
+		status: 400,
+		error: "label required"
+	};
+	const columnId = uniqueId(slugify(input.label), new Set(columns.map((column) => column.id)));
+	const columnToAdd = {
+		id: columnId,
+		label: input.label.trim()
+	};
+	if (input.isDone === true) columnToAdd.isDone = true;
+	if (input.isDone === true) {
+		const nextColumns = [...columns.map((column) => ({
+			...column,
+			isDone: false
+		})), columnToAdd];
+		const { items: nextItems, changed } = resyncDoneMembership(items, columnId);
+		return {
+			kind: "success",
+			columns: nextColumns,
+			...changed ? { items: nextItems } : {}
+		};
+	}
+	return {
+		kind: "success",
+		columns: [...columns, columnToAdd]
+	};
+}
+function handlePatchColumn(columns, columnId, input, items) {
+	const target = findColumn(columns, columnId);
+	if (!target) return {
+		kind: "error",
+		status: 404,
+		error: `column not found: ${columnId}`
+	};
+	const patched = {
+		id: target.id,
+		label: target.label
+	};
+	if (target.isDone) patched.isDone = true;
+	if (typeof input.label === "string" && input.label.trim().length > 0) patched.label = input.label.trim();
+	let nextColumns = columns.map((column) => column.id === columnId ? patched : column);
+	let itemsChanged = false;
+	let nextItems = items;
+	if (input.isDone === true && !target.isDone) {
+		nextColumns = nextColumns.map((column) => column.id === columnId ? {
+			...column,
+			isDone: true
+		} : {
+			id: column.id,
+			label: column.label
+		});
+		const synced = resyncDoneMembership(items, columnId);
+		nextItems = synced.items;
+		itemsChanged = synced.changed;
+	} else if (input.isDone === false && target.isDone) return {
+		kind: "error",
+		status: 400,
+		error: "at least one column must be marked as done"
+	};
+	return {
+		kind: "success",
+		columns: nextColumns,
+		...itemsChanged ? { items: nextItems } : {}
+	};
+}
+function handleDeleteColumn(columns, columnId, items) {
+	if (columns.length <= 1) return {
+		kind: "error",
+		status: 400,
+		error: "cannot delete the last remaining column"
+	};
+	const target = findColumn(columns, columnId);
+	if (!target) return {
+		kind: "error",
+		status: 404,
+		error: `column not found: ${columnId}`
+	};
+	const remaining = columns.filter((column) => column.id !== columnId);
+	let nextColumns = remaining;
+	if (target.isDone) nextColumns = remaining.map((column, i) => i === remaining.length - 1 ? {
+		...column,
+		isDone: true
+	} : column);
+	const newDoneId = doneColumnId(nextColumns);
+	const refugeId = target.isDone ? newDoneId : defaultStatusId(nextColumns);
+	let itemsChanged = false;
+	let nextItems = items.map((item) => {
+		if (item.status !== columnId) return item;
+		itemsChanged = true;
+		return {
+			...item,
+			status: refugeId
+		};
+	});
+	if (itemsChanged) nextItems = rebuildColumnOrder(nextItems, refugeId);
+	if (target.isDone) {
+		const synced = resyncDoneMembership(nextItems, newDoneId);
+		nextItems = synced.items;
+		itemsChanged = itemsChanged || synced.changed;
+	}
+	return {
+		kind: "success",
+		columns: nextColumns,
+		...itemsChanged ? { items: nextItems } : {}
+	};
+}
+function handleReorderColumns(columns, ids) {
+	if (!Array.isArray(ids)) return {
+		kind: "error",
+		status: 400,
+		error: "ids array required"
+	};
+	if (ids.length !== columns.length) return {
+		kind: "error",
+		status: 400,
+		error: "ids must contain every existing column id exactly once"
+	};
+	const known = new Set(columns.map((column) => column.id));
+	const seen = /* @__PURE__ */ new Set();
+	for (const columnId of ids) {
+		if (!known.has(columnId) || seen.has(columnId)) return {
+			kind: "error",
+			status: 400,
+			error: "ids must contain every existing column id exactly once"
+		};
+		seen.add(columnId);
+	}
+	const byId = new Map(columns.map((column) => [column.id, column]));
+	return {
+		kind: "success",
+		columns: ids.map((columnId) => {
+			const column = byId.get(columnId);
+			if (!column) throw new Error(`reorderColumns: missing column for id "${columnId}" (set-equality check above missed it)`);
+			return column;
+		})
+	};
+}
+//#endregion
+//#region src/handlers/items.ts
+var ORDER_STEP = 1e3;
+var PRIORITIES = [
+	"low",
+	"medium",
+	"high",
+	"urgent"
+];
+function migrateItems(rawItems, columns) {
+	const doneId = doneColumnId(columns);
+	const openId = defaultStatusId(columns);
+	const validStatusIds = new Set(columns.map((column) => column.id));
+	const withStatus = rawItems.map((item) => {
+		if (typeof item.status === "string" && validStatusIds.has(item.status)) return item;
+		const status = item.completed ? doneId : openId;
+		return {
+			...item,
+			status
+		};
+	});
+	const byStatus = /* @__PURE__ */ new Map();
+	for (const item of withStatus) {
+		const key = item.status ?? openId;
+		let bucket = byStatus.get(key);
+		if (!bucket) {
+			bucket = [];
+			byStatus.set(key, bucket);
+		}
+		bucket.push(item);
+	}
+	const orderById = /* @__PURE__ */ new Map();
+	for (const [, group] of byStatus) {
+		const missing = group.filter((item) => typeof item.order !== "number");
+		if (missing.length === 0) continue;
+		const existingMax = group.filter((item) => typeof item.order === "number").reduce((acc, item) => Math.max(acc, item.order ?? 0), 0);
+		[...missing].sort((left, right) => left.createdAt - right.createdAt).forEach((item, i) => {
+			orderById.set(item.id, existingMax + (i + 1) * ORDER_STEP);
+		});
+	}
+	return withStatus.map((item) => {
+		const next = orderById.get(item.id);
+		if (next === void 0) return item;
+		return {
+			...item,
+			order: next
+		};
+	});
+}
+function isPriority(value) {
+	return typeof value === "string" && PRIORITIES.includes(value);
+}
+function isDueDate(value) {
+	return typeof value === "string" && /^\d{4}-\d{2}-\d{2}$/.test(value);
+}
+function nextOrder(items, statusId) {
+	const inColumn = items.filter((item) => item.status === statusId).map((item) => item.order ?? 0);
+	if (inColumn.length === 0) return ORDER_STEP;
+	return Math.max(...inColumn) + ORDER_STEP;
+}
+function resolveStatus(input, columns) {
+	if (input.status === void 0 || input.status === "") return {
+		kind: "ok",
+		status: defaultStatusId(columns)
+	};
+	if (new Set(columns.map((column) => column.id)).has(input.status)) return {
+		kind: "ok",
+		status: input.status
+	};
+	return {
+		kind: "error",
+		status: 400,
+		error: `unknown status: ${input.status}`
+	};
+}
+function applyOptionalFields(item, input) {
+	if (input.priority !== void 0 && input.priority !== "") {
+		if (!isPriority(input.priority)) return {
+			kind: "error",
+			status: 400,
+			error: "invalid priority"
+		};
+		item.priority = input.priority;
+	}
+	if (input.dueDate !== void 0 && input.dueDate !== "") {
+		if (!isDueDate(input.dueDate)) return {
+			kind: "error",
+			status: 400,
+			error: "dueDate must be YYYY-MM-DD"
+		};
+		item.dueDate = input.dueDate;
+	}
+	return null;
+}
+function handleCreate(items, columns, input) {
+	if (!input.text || input.text.trim().length === 0) return {
+		kind: "error",
+		status: 400,
+		error: "text required"
+	};
+	const resolved = resolveStatus(input, columns);
+	if (resolved.kind === "error") return resolved;
+	const { status } = resolved;
+	const item = {
+		id: makeId("todo"),
+		text: input.text.trim(),
+		completed: status === doneColumnId(columns),
+		createdAt: Date.now(),
+		status,
+		order: nextOrder(items, status)
+	};
+	if (input.note !== void 0 && input.note !== "") item.note = input.note;
+	const normalizedLabels = mergeLabels([], input.labels ?? []);
+	if (normalizedLabels.length > 0) item.labels = normalizedLabels;
+	const fieldError = applyOptionalFields(item, input);
+	if (fieldError) return fieldError;
+	return {
+		kind: "success",
+		items: [...items, item],
+		item
+	};
+}
+function applyTextPatch(updated, input) {
+	if (typeof input.text !== "string") return null;
+	if (input.text.trim().length === 0) return {
+		kind: "error",
+		status: 400,
+		error: "text cannot be empty"
+	};
+	updated.text = input.text.trim();
+	return null;
+}
+function applyNotePatch(updated, input) {
+	if (input.note === null || input.note === "") {
+		delete updated.note;
+		return null;
+	}
+	if (typeof input.note === "string") updated.note = input.note;
+	return null;
+}
+function applyLabelsPatch(updated, input) {
+	if (!Array.isArray(input.labels)) return null;
+	const merged = mergeLabels([], input.labels);
+	if (merged.length > 0) updated.labels = merged;
+	else delete updated.labels;
+	return null;
+}
+function applyPriorityPatch(updated, input) {
+	if (input.priority === null || input.priority === "") {
+		delete updated.priority;
+		return null;
+	}
+	if (input.priority === void 0) return null;
+	if (!isPriority(input.priority)) return {
+		kind: "error",
+		status: 400,
+		error: "invalid priority"
+	};
+	updated.priority = input.priority;
+	return null;
+}
+function applyDueDatePatch(updated, input) {
+	if (input.dueDate === null || input.dueDate === "") {
+		delete updated.dueDate;
+		return null;
+	}
+	if (input.dueDate === void 0) return null;
+	if (!isDueDate(input.dueDate)) return {
+		kind: "error",
+		status: 400,
+		error: "dueDate must be YYYY-MM-DD"
+	};
+	updated.dueDate = input.dueDate;
+	return null;
+}
+function applyStatusPatch(updated, target, items, columns, input) {
+	if (typeof input.status !== "string" || input.status === target.status) return null;
+	if (!new Set(columns.map((column) => column.id)).has(input.status)) return {
+		kind: "error",
+		status: 400,
+		error: `unknown status: ${input.status}`
+	};
+	updated.status = input.status;
+	updated.order = nextOrder(items, input.status);
+	updated.completed = input.status === doneColumnId(columns);
+	return null;
+}
+function applyCompletedPatch(updated, items, columns, input) {
+	if (typeof input.completed !== "boolean") return null;
+	if (input.completed === updated.completed) return null;
+	updated.completed = input.completed;
+	const targetStatus = input.completed ? doneColumnId(columns) : defaultStatusId(columns);
+	if (targetStatus !== updated.status) {
+		updated.status = targetStatus;
+		updated.order = nextOrder(items, targetStatus);
+	}
+	return null;
+}
+function handlePatch(items, columns, itemId, input) {
+	const target = items.find((item) => item.id === itemId);
+	if (!target) return {
+		kind: "error",
+		status: 404,
+		error: `item not found: ${itemId}`
+	};
+	const updated = { ...target };
+	const steps = [
+		() => applyTextPatch(updated, input),
+		() => applyNotePatch(updated, input),
+		() => applyLabelsPatch(updated, input),
+		() => applyPriorityPatch(updated, input),
+		() => applyDueDatePatch(updated, input),
+		() => applyStatusPatch(updated, target, items, columns, input),
+		() => applyCompletedPatch(updated, items, columns, input)
+	];
+	for (const step of steps) {
+		const err = step();
+		if (err) return err;
+	}
+	return {
+		kind: "success",
+		items: items.map((item) => item.id === itemId ? updated : item),
+		item: updated
+	};
+}
+function handleMove(items, columns, itemId, input) {
+	const target = items.find((item) => item.id === itemId);
+	if (!target) return {
+		kind: "error",
+		status: 404,
+		error: `item not found: ${itemId}`
+	};
+	const validStatusIds = new Set(columns.map((column) => column.id));
+	const newStatus = input.status ?? target.status ?? defaultStatusId(columns);
+	if (!validStatusIds.has(newStatus)) return {
+		kind: "error",
+		status: 400,
+		error: `unknown status: ${newStatus}`
+	};
+	const isDone = newStatus === doneColumnId(columns);
+	const updatedSelf = {
+		...target,
+		status: newStatus,
+		completed: isDone
+	};
+	const others = items.filter((item) => item.id !== itemId && item.status === newStatus).sort((left, right) => (left.order ?? 0) - (right.order ?? 0));
+	const insertAt = clampPosition(input.position, others.length);
+	const reordered = [...others];
+	reordered.splice(insertAt, 0, updatedSelf);
+	const reorderedById = /* @__PURE__ */ new Map();
+	reordered.forEach((item, i) => reorderedById.set(item.id, (i + 1) * ORDER_STEP));
+	const nextItems = items.map((item) => {
+		const newOrder = reorderedById.get(item.id);
+		if (item.id === itemId) return {
+			...updatedSelf,
+			order: newOrder ?? updatedSelf.order ?? ORDER_STEP
+		};
+		if (newOrder !== void 0) return {
+			...item,
+			order: newOrder
+		};
+		return item;
+	});
+	const finalSelf = nextItems.find((item) => item.id === itemId);
+	if (!finalSelf) throw new Error(`reorder result missing item ${itemId}`);
+	return {
+		kind: "success",
+		items: nextItems,
+		item: finalSelf
+	};
+}
+function clampPosition(raw, max) {
+	if (typeof raw !== "number" || !Number.isFinite(raw)) return max;
+	if (raw < 0) return 0;
+	if (raw > max) return max;
+	return Math.floor(raw);
+}
+function handleDeleteItem(items, itemId) {
+	if (!items.find((item) => item.id === itemId)) return {
+		kind: "error",
+		status: 404,
+		error: `item not found: ${itemId}`
+	};
+	return {
+		kind: "success",
+		items: items.filter((item) => item.id !== itemId)
+	};
+}
+//#endregion
+//#region src/io.ts
+var TODOS_FILE = "todos.json";
+var COLUMNS_FILE = "columns.json";
+async function readJson(files, rel) {
+	if (!await files.exists(rel)) return void 0;
+	try {
+		return JSON.parse(await files.read(rel));
+	} catch {
+		return;
+	}
+}
+function isTodoItem(value) {
+	if (!value || typeof value !== "object") return false;
+	const obj = value;
+	return typeof obj.id === "string" && typeof obj.text === "string" && typeof obj.completed === "boolean" && typeof obj.createdAt === "number";
+}
+async function loadColumns(files) {
+	return normalizeColumns(await readJson(files, COLUMNS_FILE) ?? DEFAULT_COLUMNS);
+}
+async function saveColumns(files, columns) {
+	await files.write(COLUMNS_FILE, JSON.stringify(columns, null, 2));
+}
+async function loadTodos(files) {
+	const raw = await readJson(files, TODOS_FILE);
+	return migrateItems(Array.isArray(raw) ? raw.filter(isTodoItem) : [], await loadColumns(files));
+}
+async function saveTodos(files, items) {
+	await files.write(TODOS_FILE, JSON.stringify(items, null, 2));
+}
+//#endregion
+//#region src/handlers/llm.ts
+function findTodoByText(items, text) {
+	const needle = text.toLowerCase();
+	return items.find((i) => i.text.toLowerCase().includes(needle));
+}
+function handleShow(items, input) {
+	const filterLabels = input.filterLabels ?? [];
+	const filtered = filterByLabels(items, filterLabels);
+	return {
+		kind: "success",
+		items: filtered,
+		message: filterLabels.length > 0 ? `Showing ${filtered.length} of ${items.length} todo item(s) filtered by: ${filterLabels.join(", ")}` : `Showing ${items.length} todo item(s)`,
+		jsonData: { items: filtered.map((i) => ({
+			text: i.text,
+			completed: i.completed,
+			...i.labels && i.labels.length > 0 && { labels: i.labels }
+		})) }
+	};
+}
+function handleAdd(items, input) {
+	if (!input.text) return {
+		kind: "error",
+		status: 400,
+		error: "text required"
+	};
+	const normalizedLabels = mergeLabels([], input.labels ?? []);
+	const item = {
+		id: makeId("todo"),
+		text: input.text,
+		...input.note !== void 0 && { note: input.note },
+		...normalizedLabels.length > 0 && { labels: normalizedLabels },
+		completed: false,
+		createdAt: Date.now()
+	};
+	return {
+		kind: "success",
+		items: [...items, item],
+		message: normalizedLabels.length > 0 ? `Added: "${input.text}" [${normalizedLabels.join(", ")}]` : `Added: "${input.text}"`,
+		jsonData: {
+			added: input.text,
+			labels: normalizedLabels
+		}
+	};
+}
+function handleDelete(items, input) {
+	if (!input.text) return {
+		kind: "error",
+		status: 400,
+		error: "text required"
+	};
+	const needle = input.text.toLowerCase();
+	const next = items.filter((i) => !i.text.toLowerCase().includes(needle));
+	return {
+		kind: "success",
+		items: next,
+		message: next.length < items.length ? `Deleted: "${input.text}"` : `Item not found: "${input.text}"`,
+		jsonData: { deleted: input.text }
+	};
+}
+function handleUpdate(items, input) {
+	if (!input.text || !input.newText) return {
+		kind: "error",
+		status: 400,
+		error: "text and newText required"
+	};
+	const target = findTodoByText(items, input.text);
+	if (!target) return {
+		kind: "success",
+		items,
+		message: `Item not found: "${input.text}"`,
+		jsonData: {}
+	};
+	const oldText = target.text;
+	const updated = {
+		...target,
+		text: input.newText,
+		note: input.note !== void 0 ? input.note || void 0 : target.note
+	};
+	return {
+		kind: "success",
+		items: items.map((i) => i.id === target.id ? updated : i),
+		message: `Updated: "${oldText}" → "${input.newText}"`,
+		jsonData: {
+			oldText,
+			newText: input.newText
+		}
+	};
+}
+function setCompleted(items, input, completed, verb, jsonKey) {
+	if (!input.text) return {
+		kind: "error",
+		status: 400,
+		error: "text required"
+	};
+	const target = findTodoByText(items, input.text);
+	if (!target) return {
+		kind: "success",
+		items,
+		message: `Item not found: "${input.text}"`,
+		jsonData: {}
+	};
+	const updated = {
+		...target,
+		completed
+	};
+	return {
+		kind: "success",
+		items: items.map((i) => i.id === target.id ? updated : i),
+		message: `${verb}: "${target.text}"`,
+		jsonData: { [jsonKey]: target.text }
+	};
+}
+function handleCheck(items, input) {
+	return setCompleted(items, input, true, "Checked", "checkedItem");
+}
+function handleUncheck(items, input) {
+	return setCompleted(items, input, false, "Unchecked", "uncheckedItem");
+}
+function handleClearCompleted(items) {
+	const count = items.filter((i) => i.completed).length;
+	return {
+		kind: "success",
+		items: items.filter((i) => !i.completed),
+		message: `Cleared ${count} completed item(s)`,
+		jsonData: { clearedCount: count }
+	};
+}
+function handleAddLabel(items, input) {
+	if (!input.text || !input.labels || input.labels.length === 0) return {
+		kind: "error",
+		status: 400,
+		error: "text and a non-empty labels array required"
+	};
+	const target = findTodoByText(items, input.text);
+	if (!target) return {
+		kind: "success",
+		items,
+		message: `Item not found: "${input.text}"`,
+		jsonData: { notFound: input.text }
+	};
+	const merged = mergeLabels(target.labels ?? [], input.labels);
+	const updated = {
+		...target,
+		labels: merged
+	};
+	return {
+		kind: "success",
+		items: items.map((i) => i.id === target.id ? updated : i),
+		message: `Labels on "${target.text}": ${merged.join(", ")}`,
+		jsonData: {
+			item: target.text,
+			labels: merged
+		}
+	};
+}
+function handleRemoveLabel(items, input) {
+	if (!input.text || !input.labels || input.labels.length === 0) return {
+		kind: "error",
+		status: 400,
+		error: "text and a non-empty labels array required"
+	};
+	const target = findTodoByText(items, input.text);
+	if (!target) return {
+		kind: "success",
+		items,
+		message: `Item not found: "${input.text}"`,
+		jsonData: { notFound: input.text }
+	};
+	const remaining = subtractLabels(target.labels ?? [], input.labels);
+	const updated = { ...target };
+	if (remaining.length > 0) updated.labels = remaining;
+	else delete updated.labels;
+	return {
+		kind: "success",
+		items: items.map((i) => i.id === target.id ? updated : i),
+		message: remaining.length > 0 ? `Labels on "${target.text}": ${remaining.join(", ")}` : `"${target.text}" now has no labels`,
+		jsonData: {
+			item: target.text,
+			labels: remaining
+		}
+	};
+}
+function handleListLabels(items) {
+	const inventory = listLabelsWithCount(items);
+	const summary = inventory.map((entry) => `${entry.label} (${entry.count})`).join(", ");
+	return {
+		kind: "success",
+		items,
+		message: inventory.length === 0 ? "No labels in use" : `${inventory.length} label(s) in use: ${summary}`,
+		jsonData: { labels: inventory }
+	};
+}
+var HANDLERS = {
+	show: handleShow,
+	add: handleAdd,
+	delete: handleDelete,
+	update: handleUpdate,
+	check: handleCheck,
+	uncheck: handleUncheck,
+	clear_completed: handleClearCompleted,
+	add_label: handleAddLabel,
+	remove_label: handleRemoveLabel,
+	list_labels: handleListLabels
+};
+function dispatchTodos(action, items, input) {
+	const handler = HANDLERS[action];
+	if (!handler) return {
+		kind: "error",
+		status: 400,
+		error: `Unknown action: ${action}`
+	};
+	return handler(items, input);
+}
+//#endregion
+//#region src/handlers/priority-notifier.ts
+var PLUGIN_DATA_KIND = "todo-priority";
+var NAVIGATE_TARGET = "/todos";
+var TITLE_MAX = 60;
+var BODY_MAX = 4e3;
+var TICKETS_FILE = "urgent-tickets.json";
+function isTicket(value) {
+	if (!value || typeof value !== "object") return false;
+	const t = value;
+	if (typeof t["todoId"] !== "string") return false;
+	if (typeof t["notificationId"] !== "string") return false;
+	if (t["priority"] !== "urgent" && t["priority"] !== "high") return false;
+	if (t["title"] !== void 0 && typeof t["title"] !== "string") return false;
+	if (t["body"] !== void 0 && typeof t["body"] !== "string") return false;
+	return true;
+}
+async function loadTickets(files, log) {
+	if (!await files.exists(TICKETS_FILE)) return { tickets: {} };
+	let raw;
+	try {
+		raw = JSON.parse(await files.read(TICKETS_FILE));
+	} catch (err) {
+		log?.warn("priority reconcile: tickets file unparseable; treating as empty", {
+			file: TICKETS_FILE,
+			error: String(err)
+		});
+		return { tickets: {} };
+	}
+	if (!raw || typeof raw !== "object" || !("tickets" in raw) || typeof raw.tickets !== "object" || raw.tickets === null) {
+		log?.warn("priority reconcile: tickets file has unexpected shape; treating as empty", { file: TICKETS_FILE });
+		return { tickets: {} };
+	}
+	const rawTickets = raw.tickets;
+	const out = {};
+	for (const [key, value] of Object.entries(rawTickets)) {
+		if (!isTicket(value)) continue;
+		if (value.todoId !== key) continue;
+		out[key] = value;
+	}
+	return { tickets: out };
+}
+async function saveTickets(files, file) {
+	await files.write(TICKETS_FILE, JSON.stringify(file, null, 2));
+}
+function isNotifiablePriority(priority) {
+	return priority === "urgent" || priority === "high";
+}
+function severityFor(priority) {
+	return priority === "urgent" ? "urgent" : "nudge";
+}
+function truncate(text, max) {
+	return text.length <= max ? text : `${text.slice(0, max - 1)}…`;
+}
+function buildTitle(item) {
+	return truncate(item.text, TITLE_MAX);
+}
+function buildBody(item) {
+	const note = item.note?.trim();
+	let body = "";
+	if (note) body = note;
+	else if (item.dueDate) body = `Due ${item.dueDate}`;
+	return body.length <= BODY_MAX ? body : `${body.slice(0, BODY_MAX - 1)}…`;
+}
+async function safeClear(notifier, notificationId, todoId, log) {
+	try {
+		await notifier.clear(notificationId);
+		return true;
+	} catch (err) {
+		log?.warn("priority reconcile: clear failed", {
+			notificationId,
+			todoId,
+			error: String(err)
+		});
+		return false;
+	}
+}
+async function safeUpdate(notifier, notificationId, patch, todoId, log) {
+	try {
+		await notifier.update(notificationId, patch);
+		return true;
+	} catch (err) {
+		log?.warn("priority reconcile: update failed", {
+			notificationId,
+			todoId,
+			error: String(err)
+		});
+		return false;
+	}
+}
+async function safePublish(notifier, item, priority, log) {
+	try {
+		const { id } = await notifier.publish({
+			severity: severityFor(priority),
+			lifecycle: "action",
+			title: buildTitle(item),
+			body: buildBody(item),
+			navigateTarget: NAVIGATE_TARGET,
+			pluginData: {
+				kind: PLUGIN_DATA_KIND,
+				todoId: item.id,
+				priority
+			}
+		});
+		return id;
+	} catch (err) {
+		log?.warn("priority reconcile: publish failed", {
+			todoId: item.id,
+			error: String(err)
+		});
+		return null;
+	}
+}
+/** Reconcile the plugin's tickets and the host's bell entries with
+*  the current item list. After this resolves:
+*
+*    - every notifiable item has a ticket and a live bell, with the
+*      bell's severity / title / body matching the item's current
+*      state;
+*    - no ticket references a non-notifiable item.
+*
+*  Idempotent and tolerant of partial state. Drift is detected per-
+*  ticket against the title / body / priority stored at last publish
+*  or update; an item rename flows through `notifier.update` rather
+*  than clear-then-publish, preserving the notificationId. */
+async function reconcilePriorityNotifications(items, notifier, files, log) {
+	const ticketsFile = await loadTickets(files, log);
+	const itemsById = new Map(items.map((item) => [item.id, item]));
+	let dirty = false;
+	for (const [todoId, ticket] of Object.entries(ticketsFile.tickets)) {
+		const item = itemsById.get(todoId);
+		if (!(item !== void 0 && !item.completed && isNotifiablePriority(item.priority))) {
+			if (await safeClear(notifier, ticket.notificationId, todoId, log)) {
+				delete ticketsFile.tickets[todoId];
+				dirty = true;
+			}
+			continue;
+		}
+		if (!(await notifier.get(ticket.notificationId) !== void 0)) {
+			log?.warn("priority reconcile: ghost ticket dropped; Phase 2 will re-publish", {
+				notificationId: ticket.notificationId,
+				todoId
+			});
+			delete ticketsFile.tickets[todoId];
+			dirty = true;
+			continue;
+		}
+		const currentPriority = item.priority;
+		const desiredTitle = buildTitle(item);
+		const desiredBody = buildBody(item);
+		const priorityDrift = currentPriority !== ticket.priority;
+		const titleDrift = ticket.title !== desiredTitle;
+		const bodyDrift = ticket.body !== desiredBody;
+		if (!priorityDrift && !titleDrift && !bodyDrift) continue;
+		if (await safeUpdate(notifier, ticket.notificationId, {
+			...priorityDrift ? { severity: severityFor(currentPriority) } : {},
+			...titleDrift ? { title: desiredTitle } : {},
+			...bodyDrift ? { body: desiredBody } : {},
+			...priorityDrift ? { pluginData: {
+				kind: PLUGIN_DATA_KIND,
+				todoId,
+				priority: currentPriority
+			} } : {}
+		}, todoId, log)) {
+			ticketsFile.tickets[todoId] = {
+				todoId,
+				notificationId: ticket.notificationId,
+				priority: currentPriority,
+				title: desiredTitle,
+				body: desiredBody
+			};
+			dirty = true;
+		}
+	}
+	for (const item of items) {
+		if (item.completed || !isNotifiablePriority(item.priority)) continue;
+		if (ticketsFile.tickets[item.id]) continue;
+		const newId = await safePublish(notifier, item, item.priority, log);
+		if (newId === null) continue;
+		ticketsFile.tickets[item.id] = {
+			todoId: item.id,
+			notificationId: newId,
+			priority: item.priority,
+			title: buildTitle(item),
+			body: buildBody(item)
+		};
+		dirty = true;
+	}
+	if (dirty) try {
+		await saveTickets(files, ticketsFile);
+	} catch (err) {
+		log?.warn("priority reconcile: tickets save failed", { error: String(err) });
+	}
+}
+//#endregion
+//#region src/index.ts
+var READ_ONLY_ACTIONS = new Set(["show", "list_labels"]);
+function isLlmArgs(value) {
+	return typeof value === "object" && value !== null && "action" in value && typeof value.action === "string";
+}
+function isUiArgs(value) {
+	return typeof value === "object" && value !== null && "kind" in value && typeof value.kind === "string";
+}
+var src_default = definePlugin((runtime) => {
+	const { pubsub, files, log } = runtime;
+	const { notifier } = runtime;
+	async function reconcileNotifications(items) {
+		await reconcilePriorityNotifications(items, notifier, files.data, log);
+	}
+	const bootReconcile = (async () => {
+		try {
+			await reconcileNotifications(await loadTodos(files.data));
+		} catch (err) {
+			log.warn("boot reconcile failed", { error: String(err) });
+		}
+	})();
+	async function handleLlm(args) {
+		await bootReconcile;
+		const { action, ...input } = args;
+		log.info("dispatch llm", { action });
+		const result = dispatchTodos(action, await loadTodos(files.data), input);
+		if (result.kind === "error") {
+			log.warn("dispatch llm error", {
+				action,
+				error: result.error
+			});
+			return {
+				error: result.error,
+				status: result.status
+			};
+		}
+		if (!READ_ONLY_ACTIONS.has(action)) {
+			await saveTodos(files.data, result.items);
+			await reconcileNotifications(result.items);
+			pubsub.publish("changed", {
+				reason: "llm-action",
+				action
+			});
+		}
+		return {
+			data: { items: result.items },
+			message: result.message,
+			jsonData: result.jsonData,
+			instructions: "Display the updated todo list to the user."
+		};
+	}
+	async function handleUi(args) {
+		await bootReconcile;
+		log.info("dispatch ui", { kind: args.kind });
+		if (args.kind === "listAll") {
+			const [items, columns] = await Promise.all([loadTodos(files.data), loadColumns(files.data)]);
+			return { data: {
+				items,
+				columns
+			} };
+		}
+		const [items, columns] = await Promise.all([loadTodos(files.data), loadColumns(files.data)]);
+		if (args.kind === "itemCreate") {
+			const result = handleCreate(items, columns, args);
+			if (result.kind === "error") return {
+				error: result.error,
+				status: result.status
+			};
+			await saveTodos(files.data, result.items);
+			await reconcileNotifications(result.items);
+			pubsub.publish("changed", { reason: "item-create" });
+			return {
+				data: {
+					items: result.items,
+					columns
+				},
+				...result.item && { item: result.item }
+			};
+		}
+		if (args.kind === "itemPatch") {
+			const result = handlePatch(items, columns, args.id, args);
+			if (result.kind === "error") return {
+				error: result.error,
+				status: result.status
+			};
+			await saveTodos(files.data, result.items);
+			await reconcileNotifications(result.items);
+			pubsub.publish("changed", {
+				reason: "item-patch",
+				id: args.id
+			});
+			return {
+				data: {
+					items: result.items,
+					columns
+				},
+				...result.item && { item: result.item }
+			};
+		}
+		if (args.kind === "itemMove") {
+			const result = handleMove(items, columns, args.id, args);
+			if (result.kind === "error") return {
+				error: result.error,
+				status: result.status
+			};
+			await saveTodos(files.data, result.items);
+			await reconcileNotifications(result.items);
+			pubsub.publish("changed", {
+				reason: "item-move",
+				id: args.id
+			});
+			return {
+				data: {
+					items: result.items,
+					columns
+				},
+				...result.item && { item: result.item }
+			};
+		}
+		if (args.kind === "itemDelete") {
+			const result = handleDeleteItem(items, args.id);
+			if (result.kind === "error") return {
+				error: result.error,
+				status: result.status
+			};
+			await saveTodos(files.data, result.items);
+			await reconcileNotifications(result.items);
+			pubsub.publish("changed", {
+				reason: "item-delete",
+				id: args.id
+			});
+			return { data: {
+				items: result.items,
+				columns
+			} };
+		}
+		if (args.kind === "columnsAdd") {
+			const result = handleAddColumn(columns, items, args);
+			if (result.kind === "error") return {
+				error: result.error,
+				status: result.status
+			};
+			await saveColumns(files.data, result.columns);
+			if (result.items) await saveTodos(files.data, result.items);
+			if (result.items) await reconcileNotifications(result.items);
+			pubsub.publish("changed", { reason: "column-add" });
+			return { data: {
+				items: result.items ?? items,
+				columns: result.columns
+			} };
+		}
+		if (args.kind === "columnPatch") {
+			const result = handlePatchColumn(columns, args.id, args, items);
+			if (result.kind === "error") return {
+				error: result.error,
+				status: result.status
+			};
+			await saveColumns(files.data, result.columns);
+			if (result.items) await saveTodos(files.data, result.items);
+			if (result.items) await reconcileNotifications(result.items);
+			pubsub.publish("changed", {
+				reason: "column-patch",
+				id: args.id
+			});
+			return { data: {
+				items: result.items ?? items,
+				columns: result.columns
+			} };
+		}
+		if (args.kind === "columnDelete") {
+			const result = handleDeleteColumn(columns, args.id, items);
+			if (result.kind === "error") return {
+				error: result.error,
+				status: result.status
+			};
+			await saveColumns(files.data, result.columns);
+			if (result.items) await saveTodos(files.data, result.items);
+			if (result.items) await reconcileNotifications(result.items);
+			pubsub.publish("changed", {
+				reason: "column-delete",
+				id: args.id
+			});
+			return { data: {
+				items: result.items ?? items,
+				columns: result.columns
+			} };
+		}
+		if (args.kind === "columnsOrder") {
+			const result = handleReorderColumns(columns, args.ids);
+			if (result.kind === "error") return {
+				error: result.error,
+				status: result.status
+			};
+			await saveColumns(files.data, result.columns);
+			pubsub.publish("changed", { reason: "columns-order" });
+			return { data: {
+				items,
+				columns: result.columns
+			} };
+		}
+		return {
+			error: `unknown kind: ${JSON.stringify(args)}`,
+			status: 400
+		};
+	}
+	return {
+		TOOL_DEFINITION,
+		async manageTodoList(rawArgs) {
+			if (isLlmArgs(rawArgs)) return handleLlm(rawArgs);
+			if (isUiArgs(rawArgs)) return handleUi(rawArgs);
+			return {
+				error: "unknown args shape — expected { action: ... } or { kind: ... }",
+				status: 400
+			};
+		}
+	};
+});
+//#endregion
+export { TOOL_DEFINITION, src_default as default };
+
+//# sourceMappingURL=index.js.map