taskai-cli 1.6.5__tar.gz → 1.6.6__tar.gz

{taskai_cli-1.6.5 → taskai_cli-1.6.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: taskai-cli
-Version: 1.6.5
+Version: 1.6.6
 Author-email: Alex Paskal <alexcpaskal@gmail.com>
 Requires-Python: >=3.12
 Requires-Dist: fastapi>=0.141.1

{taskai_cli-1.6.5 → taskai_cli-1.6.6}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "taskai-cli"
-version = "1.6.5"
+version = "1.6.6"
 description = ""
 authors = [{name = "Alex Paskal", email = "alexcpaskal@gmail.com"}]
 readme = "README.md"

{taskai_cli-1.6.5 → taskai_cli-1.6.6}/taskai/browser.py

@@ -24,11 +24,29 @@ def index():
     return FileResponse(os.path.join(static_abs_dir, "index.html"))
 
 
+def _resolve_comments(item):
+    """Full comment objects for an item, in comment_ids order. Skips any
+    dangling id rather than 500-ing the whole tree (id-lists are maintained
+    by hand on both sides, so a desync is possible)."""
+    comments = []
+    for cid in item.comment_ids:
+        try:
+            comments.append(db.get_comment(cid).model_dump(mode="json"))
+        except Exception:
+            continue
+    return comments
+
+
 def _full_tree():
-    return {
-        item_id: db.get_item(item_id).model_dump(mode="json")
-        for item_id in db.get_item_ids()
-    }
+    tree = {}
+    for item_id in db.get_item_ids():
+        item = db.get_item(item_id)
+        dump = item.model_dump(mode="json")
+        # not a TodoItem field — resolved here so the frontend gets comment
+        # text from the same /api/tree read as everything else
+        dump["comments"] = _resolve_comments(item)
+        tree[item_id] = dump
+    return tree
 
 
 @app.get("/api/tree")

{taskai_cli-1.6.5 → taskai_cli-1.6.6}/taskai/cli.py

@@ -92,7 +92,14 @@ class Controller:
             if v is None:
                 continue
             match k:
-                case "completed": kwargs["completed"] = bool(v)
+                case "completed":
+                    # note: bool("false") is True — parse the string, don't
+                    # cast it. Real bools (the recursive re-parse, and the
+                    # complete/done/undone dispatch) pass straight through.
+                    if isinstance(v, bool):
+                        kwargs["completed"] = v
+                    else:
+                        kwargs["completed"] = str(v).strip().lower() in ("true", "1", "yes")
                 case "due_by":
                     if isinstance(v, str):
                         kwargs["due_by"] = datetime.strptime(v, "%m-%d-%Y")

{taskai_cli-1.6.5 → taskai_cli-1.6.6}/taskai/static/editpanel.js

@@ -7,7 +7,7 @@ const editToggle = document.getElementById("edit-toggle");
 const editBody = document.querySelector("#edit-panel .edit-body");
 
 const EDIT_PANEL_COLLAPSED_WIDTH = 44;
-const EDIT_PANEL_EXPANDED_WIDTH = 320;
+const EDIT_PANEL_EXPANDED_WIDTH = 448;
 
 // reserve the collapsed strip's width in the canvas from the start (instant —
 // there's nothing on screen yet to animate a transition from)
@@ -36,11 +36,14 @@ function dateInputValueToCliFormat(value) {
 // `param` overrides the CLI flag name where it differs from the JSON key.
 const FIELD_DEFS = [
 	{ key: "name", label: "Name", type: "text" },
-	{ key: "description", label: "Description", type: "textarea" },
 	{ key: "status", label: "Status", type: "text" },
 	{ key: "priority", label: "Priority", type: "number" },
 	{ key: "due_by", label: "Due by", type: "date", format: isoToDateInputValue },
 	{ key: "completed", label: "Completed", type: "checkbox" },
+	// description goes last and is flagged `grow`: it's the big free-text
+	// field, so it sits at the bottom and stretches to fill whatever panel
+	// height is left (see .edit-field-grow in style.css)
+	{ key: "description", label: "Description", type: "textarea", grow: true },
 ];
 
 // debounce field updates so we're not POSTing on every keystroke — only
@@ -76,6 +79,29 @@ async function sendFieldUpdate(item, def, value) {
 	applyTree(data.tree);
 }
 
+// adds a comment via the same command pipeline as everything else —
+// `comment <id> "<text>"`. The returned tree carries the new comment (see
+// _resolve_comments in browser.py), so applyTree refreshes the list.
+async function sendComment(itemId, text) {
+	const command = `comment ${itemId} ${quoteArg(text)}`;
+
+	let data;
+	try {
+		const res = await fetch("/api/command", {
+			method: "POST",
+			headers: { "Content-Type": "application/json" },
+			body: JSON.stringify({ input: command }),
+		});
+		data = await res.json();
+	} catch (err) {
+		appendLine(`Error adding comment to item ${itemId}: ${err.message}`);
+		return;
+	}
+
+	if (data.output) appendLine(data.output);
+	applyTree(data.tree);
+}
+
 function handleFieldChange(item, def, value) {
 	if (def.type === "checkbox") {
 		sendFieldUpdate(item, def, value ? "true" : "false");
@@ -95,37 +121,49 @@ function handleFieldChange(item, def, value) {
 	}, FIELD_UPDATE_DEBOUNCE_MS);
 }
 
+// the value to show in a field's input for the given item — checkbox uses
+// the boolean directly (assigned to .checked), the rest get a string .value
+function fieldDisplayValue(item, def) {
+	const raw = item[def.key];
+	if (def.type === "checkbox") return Boolean(raw);
+	if (def.type === "textarea") return raw || "";
+	if (def.format) return def.format(raw);
+	return raw ?? "";
+}
+
 function buildField(item, def) {
 	const wrapper = document.createElement("label");
 	wrapper.className = "edit-field";
+	if (def.grow) wrapper.classList.add("edit-field-grow");
 
 	const labelText = document.createElement("span");
 	labelText.className = "edit-field-label";
 	labelText.textContent = def.label;
 	wrapper.appendChild(labelText);
 
-	const rawValue = item[def.key];
 	let input;
 
 	if (def.type === "textarea") {
 		input = document.createElement("textarea");
-		input.value = rawValue || "";
+		input.value = fieldDisplayValue(item, def);
 		wrapper.appendChild(input);
 	} else if (def.type === "checkbox") {
 		const row = document.createElement("div");
 		row.className = "edit-field-checkbox-row";
 		input = document.createElement("input");
 		input.type = "checkbox";
-		input.checked = Boolean(rawValue);
+		input.checked = fieldDisplayValue(item, def);
 		row.appendChild(input);
 		wrapper.appendChild(row);
 	} else {
 		input = document.createElement("input");
 		input.type = def.type; // "text", "number", or "date"
-		input.value = def.format ? def.format(rawValue) : (rawValue ?? "");
+		input.value = fieldDisplayValue(item, def);
 		wrapper.appendChild(input);
 	}
 
+	input.dataset.fieldKey = def.key; // for the in-place refresh in renderEditForm
+
 	// checkboxes are a single discrete action (send immediately); everything
 	// else listens on "input" so the debounce in handleFieldChange can wait
 	// out a pause in typing rather than requiring the field to lose focus
@@ -138,7 +176,121 @@ function buildField(item, def) {
 	return wrapper;
 }
 
+// "YYYY-MM-DDTHH:MM:SS..." -> "Sep 3, 2026"; empty string if unparseable
+function formatCommentDate(iso) {
+	if (!iso) return "";
+	const d = new Date(iso);
+	if (isNaN(d.getTime())) return "";
+	return d.toLocaleDateString(undefined, { month: "short", day: "numeric", year: "numeric" });
+}
+
+// (re)fill a <ul.comment-list> from an item's resolved `comments` array.
+// Oldest first, newest at the bottom; keeps the view pinned to the bottom
+// (newest) unless the user has deliberately scrolled up into the history.
+function renderCommentList(listEl, comments) {
+	const prevScrollTop = listEl.scrollTop;
+	const stickToBottom =
+		listEl.scrollHeight - listEl.scrollTop - listEl.clientHeight < 8;
+
+	listEl.innerHTML = "";
+
+	if (!comments || !comments.length) {
+		const empty = document.createElement("li");
+		empty.className = "comment-empty";
+		empty.textContent = "No comments yet.";
+		listEl.appendChild(empty);
+		return;
+	}
+
+	comments.forEach(c => {
+		const li = document.createElement("li");
+		li.className = "comment-item";
+
+		// date first so it lands on the left; body second, right-aligned
+		const when = formatCommentDate(c.created_on);
+		if (when) {
+			const time = document.createElement("time");
+			time.className = "comment-date";
+			time.textContent = when;
+			li.appendChild(time);
+		}
+
+		const body = document.createElement("span");
+		body.className = "comment-body";
+		body.textContent = c.content;
+		li.appendChild(body);
+
+		listEl.appendChild(li);
+	});
+
+	// defer to next frame so scrollHeight is valid even on the first render
+	// (the <ul> isn't laid out yet when buildCommentsSection calls this)
+	if (stickToBottom) {
+		requestAnimationFrame(() => { listEl.scrollTop = listEl.scrollHeight; });
+	} else {
+		listEl.scrollTop = prevScrollTop; // keep the reader where they were
+	}
+}
+
+// read-only comment list + an "add" input, styled like an .edit-field
+function buildCommentsSection(item) {
+	const section = document.createElement("div");
+	section.className = "edit-field edit-comments";
+
+	const label = document.createElement("span");
+	label.className = "edit-field-label";
+	label.textContent = "Comments";
+	section.appendChild(label);
+
+	const list = document.createElement("ul");
+	list.className = "comment-list";
+	renderCommentList(list, item.comments);
+	section.appendChild(list);
+
+	const addInput = document.createElement("textarea");
+	addInput.className = "comment-add-input";
+	addInput.rows = 2;
+	addInput.placeholder = "Add a comment…";
+	// Enter sends, Shift+Enter inserts a newline
+	addInput.addEventListener("keydown", e => {
+		if (e.key !== "Enter" || e.shiftKey) return;
+		e.preventDefault();
+		const text = addInput.value.trim();
+		if (!text) return;
+		addInput.value = "";
+		sendComment(item.id, text);
+	});
+	section.appendChild(addInput);
+
+	return section;
+}
+
+// id of the item the form is currently showing, so a same-item refresh
+// (e.g. the applyTree after our own debounced field POST) can update values
+// in place instead of tearing the form down and unfocusing the live field
+let renderedItemId = null;
+
+// push fresh values into the existing inputs without rebuilding them — skips
+// whichever field the user is currently editing so we don't stomp their input
+function refreshFieldValues(item) {
+	editBody.querySelectorAll("[data-field-key]").forEach(input => {
+		if (input === document.activeElement) return;
+		const def = FIELD_DEFS.find(d => d.key === input.dataset.fieldKey);
+		if (!def) return;
+		if (def.type === "checkbox") input.checked = fieldDisplayValue(item, def);
+		else input.value = fieldDisplayValue(item, def);
+	});
+}
+
 function renderEditForm(item) {
+	if (item && String(item.id) === renderedItemId && editBody.querySelector(".edit-form")) {
+		refreshFieldValues(item);
+		const list = editBody.querySelector(".comment-list");
+		if (list) renderCommentList(list, item.comments);
+		return;
+	}
+
+	renderedItemId = item ? String(item.id) : null;
 	editBody.innerHTML = "";
 
 	if (!item) {
@@ -152,6 +304,7 @@ function renderEditForm(item) {
 	const form = document.createElement("div");
 	form.className = "edit-form";
 	FIELD_DEFS.forEach(def => form.appendChild(buildField(item, def)));
+	form.appendChild(buildCommentsSection(item)); // comment feed at the bottom
 	editBody.appendChild(form);
 }
 

{taskai_cli-1.6.5 → taskai_cli-1.6.6}/taskai/static/style.css

@@ -1,3 +1,10 @@
+:root {
+	/* console panel heights — also used to keep the edit panel clear of it */
+	--console-h-collapsed: 44px;
+	--console-h-expanded: 280px;
+	--comment-list-h: 200px;
+}
+
 html, body {
 	margin: 0;
 	padding: 0;
@@ -17,19 +24,19 @@ canvas {
 	left: 0;
 	right: 0;
 	bottom: 0;
-	z-index: 11; /* stay above the edit panel in the shared bottom-right corner */
+	z-index: 11; /* above the edit panel (which now stops short of it anyway) */
 	display: flex;
 	flex-direction: column;
 	background: #ffffff;
 	border-top: 1px solid #e2e4ea;
 	box-shadow: 0 -2px 10px rgba(15, 23, 42, 0.06);
-	height: 44px;
+	height: var(--console-h-collapsed);
 	overflow: hidden;
 	transition: height 0.2s ease;
 }
 
 .console-panel.expanded {
-	height: 280px;
+	height: var(--console-h-expanded);
 }
 
 .console-toggle {
@@ -114,14 +121,20 @@ canvas {
 	transition: width 0.2s ease, height 0.2s ease, background-color 0.2s ease, box-shadow 0.2s ease;
 }
 
+/* stop short of the console so the two panels never overlap in the
+   bottom-right corner — height tracks the console's collapsed/expanded state */
 .edit-panel.expanded {
-	width: 320px;
-	height: 100vh;
+	width: 448px;
+	height: calc(100vh - var(--console-h-collapsed));
 	background: #ffffff;
 	border-left: 1px solid #e2e4ea;
 	box-shadow: -2px 0 10px rgba(15, 23, 42, 0.06);
 }
 
+body:has(.console-panel.expanded) .edit-panel.expanded {
+	height: calc(100vh - var(--console-h-expanded));
+}
+
 .edit-toggle {
 	display: flex;
 	align-items: center;
@@ -164,20 +177,57 @@ canvas {
 .edit-form {
 	display: flex;
 	flex-direction: column;
-	gap: 16px;
-	padding: 16px;
+	gap: 10px;
+	padding: 12px 14px;
+	min-height: 100%;
+	box-sizing: border-box;
 }
 
+/* label sits inline on the left, control fills the rest — packs the form
+   in much tighter vertically than stacked label/control did */
 .edit-field {
 	display: flex;
-	flex-direction: column;
-	gap: 6px;
-	font-size: 12.5px;
+	flex-direction: row;
+	align-items: center;
+	gap: 10px;
+	font-size: 12px;
 	color: #6b7280;
 }
 
 .edit-field-label {
 	font-weight: 500;
+	flex: none;
+	width: 76px;
+}
+
+/* description + comments break the row rule: label back on top, full width */
+.edit-field-grow,
+.edit-comments {
+	flex-direction: column;
+	align-items: stretch;
+	gap: 6px;
+}
+
+.edit-field-grow > .edit-field-label,
+.edit-comments > .edit-field-label {
+	width: auto;
+}
+
+/* description takes whatever vertical space is left; the comment feed below
+   it is a fixed-size block (list scrolls on overflow, add box is a couple
+   of lines) so it doesn't fight the description for room */
+.edit-field-grow {
+	flex: 1 1 auto;
+	min-height: 0;
+}
+
+.edit-comments {
+	flex: none;
+}
+
+.edit-field-grow textarea {
+	flex: 1;
+	min-height: 96px;
 }
 
 .edit-field input[type="text"],
@@ -189,10 +239,11 @@ canvas {
 	color: #23252b;
 	background: #f5f6f8;
 	border: 1px solid #e2e4ea;
-	border-radius: 8px;
-	padding: 8px 10px;
+	border-radius: 6px;
+	padding: 5px 8px;
 	box-sizing: border-box;
-	width: 100%;
+	flex: 1 1 auto;
+	min-width: 0;
 	outline: none;
 }
 
@@ -205,12 +256,13 @@ canvas {
 
 .edit-field textarea {
 	resize: vertical;
-	min-height: 60px;
+	min-height: 52px;
 }
 
 .edit-field-checkbox-row {
 	display: flex;
 	align-items: center;
+	flex: 1 1 auto;
 }
 
 .edit-field-checkbox-row input[type="checkbox"] {
@@ -218,3 +270,76 @@ canvas {
 	height: 16px;
 	accent-color: #4772fa;
 }
+
+/* comments: a flat read-only feed (no cards — straight on the panel) plus
+   an add input, sitting below description */
+.comment-list {
+	list-style: none;
+	margin: 0;
+	padding: 0;
+	display: flex;
+	flex-direction: column;
+	gap: 10px;
+	height: var(--comment-list-h);
+	overflow-y: auto;
+	transition: height 0.2s ease;
+}
+
+/* when the console is open the edit panel is shorter — split that loss
+   evenly between the description box and the comment list rather than
+   taking it all out of the description */
+body:has(.console-panel.expanded) .comment-list {
+	height: calc(
+		var(--comment-list-h)
+		- (var(--console-h-expanded) - var(--console-h-collapsed)) / 2
+	);
+}
+
+/* date pinned left, comment text pinned right and wrapping under itself */
+.comment-item {
+	display: flex;
+	gap: 12px;
+	align-items: baseline;
+}
+
+.comment-date {
+	flex: none;
+	font-size: 11px;
+	color: #9aa0ab;
+}
+
+.comment-body {
+	flex: 1;
+	min-width: 0;
+	text-align: right;
+	font-size: 12.5px;
+	color: #23252b;
+	white-space: pre-wrap;
+	word-break: break-word;
+}
+
+.comment-empty {
+	font-size: 12px;
+	color: #9aa0ab;
+	font-style: italic;
+}
+
+.comment-add-input {
+	flex: none;
+	font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, Helvetica, Arial, sans-serif;
+	font-size: 13px;
+	color: #23252b;
+	background: #f5f6f8;
+	border: 1px solid #e2e4ea;
+	border-radius: 6px;
+	padding: 5px 8px;
+	box-sizing: border-box;
+	width: 100%;
+	height: 52px;
+	resize: none;
+	outline: none;
+}
+
+.comment-add-input:focus {
+	border-color: #4772fa;
+}