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

{taskai_cli-1.6.3 → taskai_cli-1.6.6}/DEVLOG.md

@@ -1,3 +1,43 @@
+# 9-3
+
+Browser session — console-driven navigation and selection, mostly beyond the
+original Phase 1 scope (DEVPLAN 1.7 has the durable version):
+
+- Synthetic invisible root node (`canvas.js`, `rootNode` / `"__root__"`) —
+  never drawn or hit-tested, sits above the real roots as the nav anchor and
+  the "whole tree / nothing specific" selection. `selectedNode` is now never
+  null: defaults to `rootNode`, and an empty-canvas click selects it.
+- `show all` / bare `show` — client-side console command: refetch `/api/tree`,
+  select the root, `fitAll()` (eases the view out until the whole forest fits
+  with padding). `show <id|name>` selects + focuses the resolved node without
+  opening the edit panel (that's `edit <id|name>`).
+- Tree navigation — `navigate(direction)` + `up`/`down`/`left`/`right` console
+  commands. Nodes got a `parent` back-ref; walks up/down/across siblings,
+  wraps on both axes. Each move acts like `show <target>`.
+- `.` as a standalone console token → selected node's id (`resolveDotRefs`),
+  so `update . --priority 3`, `done .`, `edit .` work. Leaves `a.md` / `3.5`
+  alone; errors if nothing real is selected.
+- `hide edit` console command → `closeEditPanel()`, complements `edit <id>`.
+- Up-arrow console history (was the last open Phase 1.6 item) — done earlier
+  (`commandHistory` in `console.js`), just now checked off in DEVPLAN.
+
+CLI (not browser): added `task undone <id>`, and made recursion on
+`complete`/`done` an opt-in `-r` / `-recursive` flag instead of always-on.
+Resynced the docs for it — `help_menu.py` (`help_general` + `help_examples`,
+which is also the AI's command reference) and the hand-written mentions in
+`docs/getting-started.md` / `docs/item-data.md`. `docs/commands.md` is a
+`literalinclude` of generated help text, so it tracks automatically.
+
+Fixed the long-standing `update_item` quirk: it now calls
+`_parse_item_kwargs` before `db.update_item` (like `create_item` does), so
+`update <id> --due_by MM-DD-YYYY` no longer throws. Extended
+`_parse_item_kwargs` in the same pass — maps `depends_on` (`"1,2,3"`) to
+`dependency_ids`, and guarded the `due_by` branch with `isinstance(v, str)`
+so it's idempotent for the recursive re-parse. Edit panel's Due by /
+Depends on fields round-trip now.
+
+---
+
 # 8-29
 
 Worked the TRIAGE backlog, then built out the docs.

{taskai_cli-1.6.3 → taskai_cli-1.6.6}/DEVPLAN.md

@@ -45,9 +45,11 @@ testing — don't `nuke` it.
 (methods intentionally take no `self` — called as `Controller.foo(...)`, not
 instantiated) holds all the CRUD/business logic. `execute_commands(*args,
 **kwargs)` is one big `match` statement mapping subcommands (`show`,
-`create`, `add`, `update`, `move`, `rename`, `delete`, `complete`/`done`,
-`comment`, `depend`, `link`, `reorder`, `clear`, `status`, `config`, `ai`,
-`pomo`, `repair`, `nuke`, `browser`, ...) to `Controller` calls. There's a
+`create`, `add`, `update`, `move`, `rename`, `delete`,
+`complete`/`done`/`undone`, `comment`, `link`, `reorder`, `clear`,
+`status`, `config`, `ai`, `pomo`, `repair`, `nuke`, `browser`, ...) to
+`Controller` calls. `complete`/`done`/`undone` take an opt-in `-r` /
+`-recursive` flag to apply down the subtree. There's a
 hand-rolled arg/kwarg parser (`_parse_arg_string`, `_parse_remaining`)
 instead of `argparse`. `interactive_program()` is the REPL entered when
 `task` runs with no arguments. The module connects to the database and loads
@@ -96,17 +98,20 @@ unless you're told to fix them):**
   Removed rather than wired up — `Controller.show_items` and `view_items`
   are gone (CLI audit, see DEVLOG); `task show` only ever takes one target
   now.
-- `Controller.update_item` never calls `Controller._parse_item_kwargs`
-  (`create_item` does) before handing kwargs to `db.update_item`. Confirmed
-  effects: `update <id> --due_by MM-DD-YYYY` throws a pydantic validation
-  error (the string never gets converted to a `datetime`, unlike on
-  `create`), and `update <id> --depends_on 1,2` silently no-ops (never
-  remapped to the model's real `dependency_ids` field, so pydantic just
-  drops it as an unrecognized extra key — no error, no effect). Every other
-  field (`name`, `description`, `status`, `priority`, `completed`) updates
-  correctly. The edit panel (1.5) and console both go through `update` and
-  will hit this. Likely fix: add the same
-  `kwargs = Controller._parse_item_kwargs(kwargs)` call `create_item` makes.
+- ~~`Controller.update_item` never calls `Controller._parse_item_kwargs`
+  (`create_item` does) before handing kwargs to `db.update_item`, so
+  `update <id> --due_by MM-DD-YYYY` threw a pydantic validation error and
+  `update <id> --depends_on 1,2` silently no-op'd.~~ **Fixed.**
+  `update_item` now runs `kwargs = Controller._parse_item_kwargs(kwargs)`
+  before `db.update_item`, same as `create_item`. `_parse_item_kwargs` was
+  extended in the same pass: it now also maps the CLI-facing `depends_on`
+  (a comma-separated id string, `"1,2,3"`) to the model's real
+  `dependency_ids: list[int]` — so `create --depends_on ...` works now too,
+  not just `update` — and its `due_by` branch is guarded with
+  `isinstance(v, str)` so the helper is idempotent (safe for the
+  already-parsed kwargs `update_item`'s `recursive=True` branch passes back
+  down). Edit panel's **Due by** and **Depends on** fields now round-trip
+  end to end.
 - **Sync is one-directional: CLI → browser only, not the reverse.**
   `GET /api/tree` (`browser.py`) reloads from disk (`db.flush()`) on every
   call, and `canvas.js` refetches on window focus, so browser-side views
@@ -286,6 +291,8 @@ stdlib `http.server` — no new dependency, consistent with "less code."
       break after any mutation). Drawn with the same accent-blue
       border/thicker stroke as hover. This is exactly the state 1.5's edit
       menu piggybacks off — not edge highlighting yet, just the node.
+      (Later, in 1.7: `selectedNode` became **never-null** — an empty
+      selection is now the synthetic `rootNode`, not `null`.)
 - [x] Color/style nodes by `completed` — soft green fill + border (see
       `STYLE.colors.nodeFill/BorderDone`), not strike-through/dim like the
       CLI. `status` ended up as a small orange text label in the node's
@@ -334,9 +341,9 @@ add new visual knobs there, not inline in `draw()`.
 
 While wiring this up, confirmed against a throwaway test item (created and
 deleted, not real data): `name`/`description`/`priority`/`completed` all
-update correctly end to end. `due_by` and `depends_on` hit the
-`update_item`/`_parse_item_kwargs` bug documented above — left unfixed on
-purpose, current call.
+update correctly end to end. `due_by` and `depends_on` originally hit the
+`update_item`/`_parse_item_kwargs` bug documented above — **now fixed** (see
+that entry), so all seven fields round-trip.
 
 ### 1.6 — Console
 
@@ -351,13 +358,58 @@ purpose, current call.
       response already carries the fresh tree. Also handles the `focus`
       field `show` commands return: calls `focusOnNode` on that id instead
       of expecting text output.
-- [ ] Up-arrow history — still open, not done.
-
-At the end of Phase 1: up-arrow console history (1.6) is the only piece
-left open (dependency/link edges (1.4) deferred to 2.0, see above). The
-DAG, edit panel, and console all funnel through one `/api/command` endpoint
-and one `/api/tree` read, as planned — that's the "less code" payoff of
-routing everything through the existing `Controller`.
+- [x] Up-arrow history — done (`console.js`). `commandHistory` array, every
+      submitted line pushed on; `ArrowUp`/`ArrowDown` walk it, an index at
+      `length` meaning "not currently browsing history", and `ArrowDown`
+      past the end restores an empty input.
+
+At the end of Phase 1: the whole 1.1–1.6 checklist is done
+(dependency/link edges (1.4) deferred to 2.0, see above). The DAG, edit
+panel, and console all funnel through one `/api/command` endpoint and one
+`/api/tree` read, as planned — that's the "less code" payoff of routing
+everything through the existing `Controller`. Console-driven canvas
+navigation then grew past the original Phase 1 scope — see 1.7.
+
+### 1.7 — Console-driven navigation & selection (post-plan, beyond original scope)
+
+Grew out of Phase 1's console + selection machinery; none of this was in
+the original checklist.
+
+- [x] **Synthetic invisible root node** (`canvas.js`, `rootNode` /
+      `"__root__"`). Never added to `nodes`, so never drawn, hit-tested, or
+      bordered. It's the nav anchor above the real root items and the
+      "nothing specific / the whole tree" selection. `selectedNode` is now
+      **never null** — it defaults to `rootNode`, and a click on empty
+      canvas selects `rootNode` rather than clearing the selection.
+      `applyTree` re-parents it over the freshly-built roots and parks it
+      one `ySpacing` above them on every refresh.
+- [x] **`show all` / bare `show`** (console, client-side). Refetches
+      `/api/tree`, selects the synthetic root, and calls `fitAll()` — eases
+      the view out until every real node fits on screen with padding,
+      clamped to `STYLE.zoom` bounds.
+- [x] **`show <id|name>`** (console, client-side). POSTs the command,
+      applies the returned tree, then selects + `focusOnNode`s the resolved
+      node. Deliberately does *not* open the edit panel — that's
+      `edit <id|name>`, mirroring the canvas's single-click vs. double-click
+      split.
+- [x] **Tree navigation** — `navigate(direction)` in `canvas.js`, wired to
+      `up` / `down` / `left` / `right` console commands. Nodes carry a
+      `parent` back-reference (set in `buildTree` / `applyTree`) so the walk
+      goes up as well as down: `down` → first child, `up` → parent,
+      `left`/`right` → previous/next sibling. Wraps on both axes — past the
+      last sibling loops to the first; `down` past the deepest leaf and `up`
+      from `rootNode` loop between the top and the deepest first-child leaf.
+      Each move behaves like a `show <target>` (select + ease/zoom; `fitAll`
+      when the target is `rootNode`).
+- [x] **`.` = the selected node** (`resolveDotRefs` in `console.js`). A bare
+      `.` token in any console command is swapped for `selectedNode.id`
+      before dispatch, so `update . --priority 3`, `done .`, `edit .` act on
+      the current selection. Only matches a standalone `.` (whitespace or
+      string end on both sides), so `a.md` / `3.5` are untouched; errors if
+      `.` is used with nothing real selected.
+- [x] **`hide edit`** (console) → `closeEditPanel()` in `editpanel.js`,
+      collapsing the right panel and restoring canvas width. Complements the
+      existing `edit <id|name>` that opens it.
 
 ---
 
@@ -544,6 +596,14 @@ Re-scope this section before starting 2.4.
       `html_baseurl` + README); explanation/architecture pages; polish
       (screenshots for browser-mode, custom 404, OpenGraph cards, CI
       `linkcheck`, tested examples, changelog).
+- [x] **`help_menu.py` drift from `execute_commands`.** The CLI gained
+      `task undone <id>` and an opt-in `-r` / `-recursive` flag on
+      `complete` / `done` (recursion used to be unconditional). Resynced:
+      `help_general` and `help_examples` in `help_menu.py` (also the AI's
+      verbatim command reference), plus the two hand-written mentions in
+      `docs/getting-started.md` and `docs/item-data.md`. `docs/commands.md`
+      needs no edit — it `literalinclude`s the `builder-inited`-generated
+      dump of `help_general`.
 - [ ] **UX pass.** Empty/loading state for the DAG when a user has no tasks
       yet (currently the app would just render nothing); a keyboard shortcut
       to toggle the console (e.g. backtick); consistent spacing/typography

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: taskai-cli
-Version: 1.6.3
+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.3 → taskai_cli-1.6.6}/docs/getting-started.md

@@ -88,10 +88,12 @@ task show 2
 task status 2 "in progress"
 task comment 2 "outline done, drafting the intro"
 task done 2
+task done 2 -r   # also complete everything under item 2
 ```
 
-`task done` (alias: `task complete`) marks the item **and everything under it**
-complete. Clean finished work up with `task clear`:
+`task done` (alias: `task complete`) marks just that item complete; add `-r`
+(or `-recursive`) to complete all its descendants too. `task undone` reverses
+it and takes the same `-r` flag. Clean finished work up with `task clear`:
 
 ```bash
 task clear "Launch blog"   # delete completed items under that parent

{taskai_cli-1.6.3 → taskai_cli-1.6.6}/docs/item-data.md

@@ -25,13 +25,16 @@ Some changes have their own command instead of an option:
 task rename 4 "Ship v2.1"
 task status 4 "in review"           # same as --status, as its own verb
 task comment 4 "waiting on QA sign-off"
-task complete 4                     # mark done — also completes descendants
+task complete 4                     # mark item 4 done
 task done 4                         # alias for complete
+task done 4 -r                      # also complete every descendant
 ```
 
-`task complete` / `task done` mark the item **and everything under it**
-complete. To reopen something, set it back explicitly:
+`task complete` / `task done` mark just that item complete; add `-r` (or
+`-recursive`) to include all its descendants. To reopen something, use
+`task undone` (which takes the same `-r` flag) or set the field explicitly:
 
 ```bash
+task undone 4
 task update 4 --completed false
 ```

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

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

{taskai_cli-1.6.3 → 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.3 → taskai_cli-1.6.6}/taskai/cli.py

@@ -86,12 +86,30 @@ class Controller:
 
 
     def _parse_item_kwargs(kwargs):
+        # idempotent: also called on the already-parsed kwargs that
+        # update_item()'s recursive branch passes back down
         for k, v in kwargs.copy().items():
             if v is None:
                 continue
             match k:
-                case "completed": kwargs["completed"] = bool(v)
-                case "due_by": kwargs["due_by"] = datetime.strptime(v, "%m-%d-%Y")
+                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")
+                case "depends_on":
+                    # CLI-facing alias for the model's dependency_ids field;
+                    # accepts a comma-separated id list ("1,2,3") or one id
+                    kwargs["dependency_ids"] = [
+                        int(x) for x in str(v).split(",") if str(x).strip()
+                    ]
+                    del kwargs["depends_on"]
         return kwargs
 
     def _get_root_ids():
@@ -137,6 +155,7 @@ class Controller:
 
     def update_item(item_id: int|str, recursive=False, **kwargs):
         item_id = Controller._resolve_item(item_id).id
+        kwargs = Controller._parse_item_kwargs(kwargs)
         db.update_item(item_id, **kwargs)
         print(f"Updated item {item_id}")
 
@@ -443,7 +462,13 @@ def execute_commands(*args, **kwargs) -> int:
                 Controller.remove_link(parent_identifier, item_identifier)
 
             case "complete" | "done":
-                Controller.update_item(args[1], completed=True, recursive=True)
+                recursive = "-r" in args or "-recursive" in args
+                Controller.update_item(args[1], completed=True, recursive=recursive)
+
+            case "undone":
+                recursive = "-r" in args or "-recursive" in args
+                Controller.update_item(args[1], completed=False, recursive=recursive)
+
 
             case "examples":
                 Controller.show_examples()

{taskai_cli-1.6.3 → taskai_cli-1.6.6}/taskai/help_menu.py

@@ -22,7 +22,8 @@ Modifying items (an id or a name works everywhere):
 'task rename {id|name} {new name}' --> rename an item
 'task status {id|name} {text}' --> set an item's status string
 'task comment {id|name} {text}' --> add a comment to an item
-'task complete {id|name}' / 'task done {id|name}' --> mark an item, and all its descendants, complete
+'task complete {id|name}' / 'task done {id|name}' --> mark an item complete; add -r (or -recursive) to also complete all its descendants
+'task undone {id|name}' --> mark an item not complete; add -r (or -recursive) to also un-complete all its descendants
 'task reorder {id1|name} before|after {id2|name}' --> reorder one item relative to a sibling
 'task move {id|name} {new parent id|name}' --> reparent an item; pass an empty string for the new parent to move it to the top level
 'task link {parent id|name} {item id|name}' --> soft-link item under parent, without reparenting it
@@ -79,7 +80,9 @@ Build a small project tree:
 Work an item and finish it:
   task status 4 "in progress"
   task comment 4 "stuck on the intro paragraph"
-  task done 4                       # completes item 4 and everything under it
+  task done 4                       # completes just item 4
+  task done 4 -r                    # completes item 4 and everything under it
+  task undone 4                     # reopen it
 
 Reorganize (reorder/rename/status take an id; move takes an id or a name):
   task move "Set up hosting" "Write first post"

{taskai_cli-1.6.3 → taskai_cli-1.6.6}/taskai/static/canvas.js

@@ -79,6 +79,13 @@ let roots = [];
 let nodes = [];
 let latestItemsById = {}; // full raw item data keyed by id, from the last /api/tree or /api/command response
 
+// synthetic, never-drawn node sitting above the real root items. It's the
+// nav anchor for top-level movement and the "selection" that means "the whole
+// tree / nothing specific" — e.g. after `show all`, or clicking empty canvas.
+// Never added to `nodes`, so it's never hit-tested, drawn, or bordered.
+const ROOT_NODE_ID = "__root__";
+const rootNode = { id: ROOT_NODE_ID, isRoot: true, label: "", size: 0, children: [], x: 0, y: 0 };
+
 // the real item behind a node — for a shadow (soft-link) node that's the
 // linked-to item (node.realId), not the synthetic shadow id
 function itemForNode(node) {
@@ -119,7 +126,7 @@ function buildTree(itemsById, id) {
 		if (linked) children.push(buildShadowNode(linked, item.id));
 	});
 
-	return {
+	const node = {
 		id: String(item.id),
 		label: item.name,
 		size: STYLE.node.size,
@@ -127,6 +134,11 @@ function buildTree(itemsById, id) {
 		status: item.status,
 		children,
 	};
+
+	// back-reference so navigation (navigate()) can walk up as well as down
+	children.forEach(child => { child.parent = node; });
+
+	return node;
 }
 
 // depth-first layout: y from depth, x from a running leaf counter shared across the whole forest,
@@ -163,10 +175,24 @@ function applyTree(itemsById) {
 
 	nodes = roots.flatMap(root => flatten(root));
 
+	// keep the synthetic root pointing at the freshly-built real roots, and
+	// park it just above them so it works as a nav origin
+	rootNode.children = roots;
+	roots.forEach(r => { r.parent = rootNode; });
+	if (roots.length) {
+		rootNode.x = roots.reduce((sum, r) => sum + r.x, 0) / roots.length;
+		rootNode.y = Math.min(...roots.map(r => r.y)) - STYLE.layout.ySpacing;
+	} else {
+		rootNode.x = 0;
+		rootNode.y = 0;
+	}
+
 	// the previously-selected node was rebuilt as a new object (or may no
 	// longer exist) — re-resolve by id so selection survives a tree refresh
 	if (selectedNode) {
-		selectedNode = nodes.find(n => n.id === selectedNode.id) || null;
+		selectedNode = selectedNode.id === ROOT_NODE_ID
+			? rootNode
+			: nodes.find(n => n.id === selectedNode.id) || rootNode;
 		if (typeof onNodeSelected === "function") {
 			onNodeSelected(itemForNode(selectedNode));
 		}
@@ -345,6 +371,70 @@ function canvasPan(dx, dy) {
 	easeView(view.offsetX + dx, view.offsetY + dy, view.scale);
 }
 
+// eases the view out until every real node fits on screen, with padding —
+// used by `show all` / bare `show`
+function fitAll(duration = STYLE.zoom.focusDurationMs) {
+	if (!nodes.length) return;
+
+	const half = STYLE.node.size / 2;
+	const minX = Math.min(...nodes.map(n => n.x)) - half;
+	const maxX = Math.max(...nodes.map(n => n.x)) + half;
+	const minY = Math.min(...nodes.map(n => n.y)) - half;
+	const maxY = Math.max(...nodes.map(n => n.y)) + half;
+
+	const pad = 60; // screen px of breathing room around the content
+	const scale = Math.min(
+		STYLE.zoom.max,
+		Math.max(
+			STYLE.zoom.min,
+			Math.min(
+				(canvas.width - pad * 2) / (maxX - minX),
+				(canvas.height - pad * 2) / (maxY - minY),
+			),
+		),
+	);
+
+	const cx = (minX + maxX) / 2;
+	const cy = (minY + maxY) / 2;
+	easeView(canvas.width / 2 - cx * scale, canvas.height / 2 - cy * scale, scale, duration);
+}
+
+// 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.
+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
+	} 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];
+		}
+	} 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];
+	}
+
+	if (!target || target === cur) return;
+
+	selectedNode = target;
+	if (typeof onNodeSelected === "function") onNodeSelected(itemForNode(target));
+	if (target === rootNode) fitAll();
+	else focusOnNode(target);
+	draw();
+}
+
 // trims text, always appending an ellipsis, until "text…" fits maxWidth
 function truncateWithEllipsis(ctx, text, maxWidth) {
 	let truncated = text;
@@ -586,8 +676,9 @@ function draw() {
 let hoveredNode = null;
 
 // selection — persists across hover and drives the edit panel (see
-// onNodeSelected, defined in editpanel.js)
-let selectedNode = null;
+// onNodeSelected, defined in editpanel.js). Never null: an empty/whole-tree
+// selection is the synthetic rootNode.
+let selectedNode = rootNode;
 
 // panning state
 let isPanning = false;
@@ -605,7 +696,7 @@ canvas.addEventListener("click", (e) => {
 
 	const clicked = nodes.find(node => hitTest(node, x, y));
 
-	selectedNode = clicked || null;
+	selectedNode = clicked || rootNode; // empty canvas -> whole-tree selection
 	if (typeof onNodeSelected === "function") {
 		onNodeSelected(itemForNode(selectedNode));
 	}

{taskai_cli-1.6.3 → taskai_cli-1.6.6}/taskai/static/console.js

@@ -30,8 +30,26 @@ const CLIENT_COMMANDS = {
 	"pan right": () => canvasPan(-PAN_AMOUNT, 0),
 	"pan up":    () => canvasPan(0, PAN_AMOUNT),
 	"pan down":  () => canvasPan(0, -PAN_AMOUNT),
+	"up":        () => navigate("up"),
+	"down":      () => navigate("down"),
+	"left":      () => navigate("left"),
+	"right":     () => navigate("right"),
+	"hide edit": () => closeEditPanel(),
 };
 
+// `.` as a standalone token refers to the currently selected node — swap it
+// for that node's id before the command is matched or sent on. Only matches a
+// bare `.` (spaces or string ends on both sides), so `a.md` / `3.5` are left
+// alone. Returns null (and reports) if `.` is used with no real selection.
+function resolveDotRefs(command) {
+	if (!/(^|\s)\.(\s|$)/.test(command)) return command;
+	if (!selectedNode || selectedNode === rootNode) {
+		appendLine("No node selected — `.` refers to the selected node");
+		return null;
+	}
+	return command.replace(/(^|\s)\.(?=\s|$)/g, `$1${selectedNode.id}`);
+}
+
 const commandHistory = [];
 let historyIndex = commandHistory.length; // length = not currently browsing history
 
@@ -52,7 +70,7 @@ consoleInput.addEventListener("keydown", async (e) => {
 	}
 	if (e.key !== "Enter") return;
 
-	const command = consoleInput.value.trim();
+	let command = consoleInput.value.trim();
 	if (!command) return;
 
 	commandHistory.push(command);
@@ -61,12 +79,65 @@ consoleInput.addEventListener("keydown", async (e) => {
 	appendLine("> " + command);
 	consoleInput.value = "";
 
+	command = resolveDotRefs(command); // `.` -> selected node's id
+	if (command === null) return;
+
 	const clientHandler = CLIENT_COMMANDS[command.toLowerCase()];
 	if (clientHandler) {
 		clientHandler();
 		return;
 	}
 
+	// `show all` / bare `show` — select the synthetic root and fit the forest
+	if (/^show(\s+all)?$/i.test(command)) {
+		let tree;
+		try {
+			const res = await fetch("/api/tree");
+			tree = await res.json();
+		} catch (err) {
+			appendLine("Error: " + err.message);
+			return;
+		}
+		applyTree(tree);
+		selectedNode = rootNode;
+		if (typeof onNodeSelected === "function") onNodeSelected(null);
+		fitAll();
+		return;
+	}
+
+	// `show <id|name>` — select + focus the resolved node. Does NOT open the
+	// edit panel (that's `edit <id|name>`), mirroring click vs. double-click.
+	const showMatch = command.match(/^show\s+(.+)$/i);
+	if (showMatch) {
+		const target = showMatch[1].trim();
+		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: " + err.message);
+			return;
+		}
+
+		applyTree(data.tree);
+
+		if (data.focus) {
+			const node = nodes.find(n => n.id === String(data.focus));
+			if (node) {
+				selectedNode = node;
+				if (typeof onNodeSelected === "function") onNodeSelected(itemForNode(node));
+				focusOnNode(node);
+			}
+		} else {
+			appendLine(data.output || `No item found matching '${target}'`);
+		}
+		return;
+	}
+
 	// `edit <id|name>` — resolve via show, then select + focus + open panel
 	const editMatch = command.match(/^edit\s+(.+)$/i);
 	if (editMatch) {
@@ -90,7 +161,7 @@ consoleInput.addEventListener("keydown", async (e) => {
 			const node = nodes.find(n => n.id === String(data.focus));
 			if (node) {
 				selectedNode = node;
-				if (typeof onNodeSelected === "function") onNodeSelected(latestItemsById[node.id]);
+				if (typeof onNodeSelected === "function") onNodeSelected(itemForNode(node));
 				focusOnNode(node);
 				if (typeof openEditPanel === "function") openEditPanel();
 			}