taskai-cli 1.7.0__tar.gz → 1.7.1__tar.gz

{taskai_cli-1.7.0 → taskai_cli-1.7.1}/PKG-INFO

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

{taskai_cli-1.7.0 → taskai_cli-1.7.1}/pyproject.toml

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

{taskai_cli-1.7.0 → taskai_cli-1.7.1}/taskai/static/canvas.js

@@ -327,9 +327,6 @@ function focusOnNode(node, scale = STYLE.zoom.focusScale, duration = STYLE.zoom.
 	const startOffsetY = view.offsetY;
 	const startScale = view.scale;
 
-	const targetOffsetX = canvas.width / 2 - node.x * scale;
-	const targetOffsetY = canvas.height * STYLE.zoom.focusYRatio - node.y * scale;
-
 	const startTime = performance.now();
 
 	function step(now) {
@@ -337,6 +334,15 @@ function focusOnNode(node, scale = STYLE.zoom.focusScale, duration = STYLE.zoom.
 		const eased = 1 - Math.pow(1 - t, 3); // ease-out cubic
 
 		view.scale = startScale + (scale - startScale) * eased;
+
+		// recompute the target each frame from the current canvas size: the
+		// canvas can be resizing under us when a side panel opens in step with
+		// this animation (e.g. the `a` add-node shortcut), and a target
+		// captured once up front would leave the node off-centre by half the
+		// width change — often hidden behind the panel that just opened.
+		const targetOffsetX = canvas.width / 2 - node.x * scale;
+		const targetOffsetY = canvas.height * STYLE.zoom.focusYRatio - node.y * scale;
+
 		view.offsetX = startOffsetX + (targetOffsetX - startOffsetX) * eased;
 		view.offsetY = startOffsetY + (targetOffsetY - startOffsetY) * eased;
 
@@ -412,35 +418,50 @@ function fitAll(duration = STYLE.zoom.focusDurationMs) {
 	easeView(canvas.width / 2 - cx * scale, canvas.height / 2 - cy * scale, scale, duration);
 }
 
+// per-parent memory of the last child navigated to, keyed by parent id (node
+// objects are rebuilt on every applyTree, so ids not references). Lets `down`
+// return to where you last were under a parent; stale ids are harmless — the
+// lookup just misses and falls back to the first child.
+const lastChildByParent = {};
+
 // moves the selection relative to the current node along the node tree.
 // The move is equivalent to a `show <target>`: the node becomes selected and
-// the view eases + zooms to it (focusOnNode). Wraps around on both axes —
-// past the last sibling loops to the first, past the bottom leaf loops back
-// to rootNode (the top), and `up` from rootNode drops to the deepest node.
+// the view eases + zooms to it (focusOnNode). up/down don't wrap — off the
+// top or past a leaf does nothing; only left/right wrap, looping to the
+// first (or last) node of the current depth level.
 function navigate(direction) {
 	const cur = selectedNode || rootNode;
 	let target = null;
 
 	if (direction === "down") {
-		target = cur.children[0] || rootNode; // past the bottom -> wrap to the top
+		if (!cur.children.length) return; // at a leaf -> nothing below
+		// return to the last child visited under `cur`, else its first child
+		const remembered = lastChildByParent[cur.id];
+		target = cur.children.find(c => c.id === remembered) || cur.children[0];
 	} else if (direction === "up") {
-		if (cur.parent) {
-			target = cur.parent;
-		} else {
-			// at rootNode (the top) -> wrap to the bottom: follow the
-			// first-child chain down to the deepest leaf
-			target = cur;
-			while (target.children[0]) target = target.children[0];
-		}
+		if (!cur.parent) return; // at the top -> nothing above
+		target = cur.parent;
 	} else if (direction === "left" || direction === "right") {
-		const sibs = cur.parent && cur.parent.children;
-		if (!sibs || !sibs.length) return;
-		const n = sibs.length;
-		target = sibs[(sibs.indexOf(cur) + (direction === "right" ? 1 : -1) + n) % n];
+		// step to the node immediately left/right at the same depth, across
+		// the whole level — so you cross into a cousin subtree rather than
+		// wrapping inside the current parent. The layout gives every node at a
+		// given depth the same y, so the level is just "nodes sharing cur.y"
+		// sorted by x; no explicit depth/level bookkeeping. Wrap to the first
+		// (or last) node of the level only when you run off its end.
+		const row = nodes
+			.filter(n => Math.abs(n.y - cur.y) < 1)
+			.sort((a, b) => a.x - b.x);
+		const i = row.indexOf(cur);
+		if (i === -1 || row.length < 2) return;
+		const step = direction === "right" ? 1 : -1;
+		target = row[(i + step + row.length) % row.length];
 	}
 
 	if (!target || target === cur) return;
 
+	// remember this child so a later `down` into its parent returns here
+	if (target.parent) lastChildByParent[target.parent.id] = target.id;
+
 	selectedNode = target;
 	if (typeof onNodeSelected === "function") onNodeSelected(itemForNode(target));
 	if (target === rootNode) fitAll();

{taskai_cli-1.7.0 → taskai_cli-1.7.1}/taskai/static/editpanel.js

@@ -102,7 +102,7 @@ async function sendComment(itemId, text) {
 	applyTree(data.tree);
 }
 
-function handleFieldChange(item, def, value) {
+function handleFieldChange(item, def, value, immediate = false) {
 	if (def.type === "checkbox") {
 		sendFieldUpdate(item, def, value ? "true" : "false");
 		return;
@@ -115,6 +115,15 @@ function handleFieldChange(item, def, value) {
 
 	const timerKey = `${item.id}:${def.key}`;
 	clearTimeout(pendingFieldUpdates[timerKey]);
+
+	// Enter (see buildField) commits right away rather than waiting out the
+	// debounce — the edit is done, no reason to sit on it
+	if (immediate) {
+		delete pendingFieldUpdates[timerKey];
+		sendFieldUpdate(item, def, value);
+		return;
+	}
+
 	pendingFieldUpdates[timerKey] = setTimeout(() => {
 		delete pendingFieldUpdates[timerKey];
 		sendFieldUpdate(item, def, value);
@@ -173,6 +182,18 @@ function buildField(item, def) {
 		handleFieldChange(item, def, value);
 	});
 
+	// Enter on a single-line field ends the edit: flush the pending update
+	// now and blur. Skipped for the textarea (Enter is a newline there) and
+	// the checkbox (toggled with space, no debounce to flush).
+	if (def.type !== "textarea" && def.type !== "checkbox") {
+		input.addEventListener("keydown", (e) => {
+			if (e.key !== "Enter") return;
+			e.preventDefault();
+			handleFieldChange(item, def, input.value, true);
+			input.blur();
+		});
+	}
+
 	return wrapper;
 }
 

{taskai_cli-1.7.0 → taskai_cli-1.7.1}/taskai/static/shortcuts.js

@@ -91,8 +91,10 @@ async function addNodeAndEdit() {
 
 	selectedNode = node;
 	if (typeof onNodeSelected === "function") onNodeSelected(itemForNode(node));
-	focusOnNode(node);
+	// open the panel first so focusOnNode eases into the already-narrowing
+	// canvas and its per-frame target tracks the new width (see focusOnNode)
 	if (typeof openEditPanel === "function") openEditPanel();
+	focusOnNode(node);
 
 	requestAnimationFrame(() => {
 		const nameInput = document.querySelector('#edit-panel [data-field-key="name"]');
@@ -113,7 +115,10 @@ function handleEscape() {
 		el.blur();
 		return;
 	}
-	showAll(); // deselects (selectedNode = rootNode) and fits the whole forest
+	// deselect, but leave the camera where it is — Esc shouldn't move/zoom
+	selectedNode = rootNode;
+	if (typeof onNodeSelected === "function") onNodeSelected(null);
+	draw();
 }
 
 // --- registry ------------------------------------------------------------
@@ -138,7 +143,7 @@ const SHORTCUTS = [
 		run: () => toggleEditPanel(),
 	},
 	{
-		combos: [{ key: "Escape" }], glyphs: ["Esc"], desc: "Leave field · deselect · show all",
+		combos: [{ key: "Escape" }], glyphs: ["Esc"], desc: "Leave field · deselect",
 		whileTyping: true, keepDefault: true,
 		run: handleEscape,
 	},