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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: taskai-cli
-Version: 1.7.0
+Version: 1.8.0
 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.8.0}/pyproject.toml

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

{taskai_cli-1.7.0 → taskai_cli-1.8.0}/taskai/browser.py

@@ -9,6 +9,13 @@ from pydantic import BaseModel
 
 from taskai.cli import Controller, _parse_arg_string, _parse_remaining, db, execute_commands
 from taskai.errors import TaskCLIError
+from taskai.filters import (
+    FilterError,
+    looks_like_filters,
+    match_items,
+    parse_filters,
+    with_ancestors,
+)
 
 
 app = FastAPI()
@@ -49,6 +56,23 @@ def _full_tree():
     return tree
 
 
+def _filtered_tree(keep):
+    """Same shape as _full_tree(), but only the ids in `keep`, with
+    child_ids / linked_ids narrowed to `keep` too so the frontend never
+    walks into a pruned-out node."""
+    tree = {}
+    for item_id in db.get_item_ids():
+        if item_id not in keep:
+            continue
+        item = db.get_item(item_id)
+        dump = item.model_dump(mode="json")
+        dump["child_ids"] = [c for c in dump["child_ids"] if c in keep]
+        dump["linked_ids"] = [l for l in dump["linked_ids"] if l in keep]
+        dump["comments"] = _resolve_comments(item)
+        tree[item_id] = dump
+    return tree
+
+
 @app.get("/api/tree")
 def get_tree():
     db.flush()  # reload from disk in case another process (e.g. the CLI) wrote since we last connected
@@ -83,6 +107,11 @@ def run_command(request: CommandRequest):
 def _run_show(args):
     """`show` is read-only from the browser's perspective: it never mutates
     the db, it just tells the frontend which node to focus/center on."""
+    show_args = list(args[1:])
+
+    if looks_like_filters(show_args):
+        return _run_filter(show_args)
+
     target = args[1] if len(args) > 1 else "all"
 
     if target == "all":
@@ -100,3 +129,25 @@ def _run_show(args):
         }
 
     return {"output": "", "tree": _full_tree(), "focus": str(item.id)}
+
+
+def _run_filter(show_args):
+    """`show attr<op>value ...` — return a pruned tree (matches + their parent
+    chains) plus a `filtered` flag so the frontend fits the view to it."""
+    try:
+        exprs = parse_filters(show_args)
+    except FilterError as e:
+        return {"output": str(e), "tree": _full_tree(), "focus": None}
+
+    matched = match_items(db, exprs)
+    if not matched:
+        return {"output": "No items match those filters", "tree": _full_tree(), "focus": None}
+
+    keep = with_ancestors(db, matched)
+    plural = "s" if len(matched) != 1 else ""
+    return {
+        "output": f"{len(matched)} item{plural} matched",
+        "tree": _filtered_tree(keep),
+        "focus": None,
+        "filtered": True,
+    }

{taskai_cli-1.7.0 → taskai_cli-1.8.0}/taskai/cli.py

@@ -11,6 +11,13 @@ import getpass
 # local
 from taskai.json_dir_database import JsonDirectoryDatabase
 from taskai.views import view_lists, view_item
+from taskai.filters import (
+    FilterError,
+    looks_like_filters,
+    match_items,
+    parse_filters,
+    with_ancestors,
+)
 from taskai.models import TodoItem, CLIConfig
 from taskai.services.ai import ai_headstart_service, ai_natural_language_service
 from taskai.services.user_setup import user_setup_service
@@ -135,6 +142,29 @@ class Controller:
             return
         view_item(db, item.id, **kwargs)
 
+    def show_filtered(tokens: list[str], **kwargs):
+        """`task show attr<op>value ...` - render only the items matching all
+        the given filters, each with its parent chain for context."""
+        try:
+            exprs = parse_filters(tokens)
+        except FilterError as e:
+            Controller.throw_error(str(e))
+            return
+
+        matched = match_items(db, exprs)
+        if not matched:
+            print("No items match those filters")
+            return
+
+        display = with_ancestors(db, matched)
+        roots = [r for r in Controller._get_root_ids() if r in display]
+        view_lists(
+            db, roots,
+            show_done=kwargs.get("show_done", True),
+            only_ids=display,
+        )
+        print(f"\n{len(matched)} item{'s' if len(matched) != 1 else ''} matched")
+
     def show_examples():
         print(help_menu["examples"])
 
@@ -411,9 +441,14 @@ def execute_commands(*args, **kwargs) -> int:
                 Controller.run_setup_service()
 
             case "show":
-                match args[1]:
-                    case "all": Controller.show_all(*args[2:], **kwargs)
-                    case _: Controller.show_item(args[1], **kwargs)
+                show_args = list(args[1:])
+                if looks_like_filters(show_args):
+                    Controller.show_filtered(show_args, **kwargs)
+                else:
+                    target = args[1] if len(args) > 1 else "all"
+                    match target:
+                        case "all": Controller.show_all(*args[2:], **kwargs)
+                        case _: Controller.show_item(target, **kwargs)
 
             case "create":
                 Controller.create_item(args[1], **kwargs)

taskai_cli-1.8.0/taskai/filters.py

@@ -0,0 +1,150 @@
+"""
+Attribute filters for `task show`.
+
+    task show status="IN PROGRESS" priority>=2 due_by<12-31-2026
+
+Each argument is one filter, `attr<op>value`, with no spaces around the
+operator (a quoted value with spaces still arrives as a single token). Every
+filter must pass for an item to match - the list is AND-ed. Text matches (`=`
+on a string attribute) use fnmatch, so `name=Write*` works; the ordering
+operators compare numbers, dates, or strings as appropriate.
+
+`match_items` returns the ids that match; `with_ancestors` pads that set out
+with every matched item's parent chain, so the result renders as a coherent
+tree rather than a scatter of disconnected nodes.
+"""
+
+import fnmatch
+import re
+from dataclasses import dataclass
+from datetime import datetime
+
+from taskai.json_dir_database import DatabaseError
+
+# attr -> how both sides of the comparison should be read
+_INT_ATTRS = {"id", "parent_id", "priority"}
+_DATE_ATTRS = {"due_by", "created_on"}
+_BOOL_ATTRS = {"completed"}
+_STR_ATTRS = {"name", "description", "status"}
+
+FILTERABLE_ATTRS = _INT_ATTRS | _DATE_ATTRS | _BOOL_ATTRS | _STR_ATTRS
+
+_DATE_FORMAT = "%m-%d-%Y"  # matches the CLI's --due_by format
+
+# two-char operators first so `>=` isn't read as `>` then `=`
+_FILTER_RE = re.compile(
+    r"^(?P<attr>[A-Za-z_][A-Za-z0-9_]*)(?P<op>>=|<=|=|>|<)(?P<value>.*)$",
+    re.DOTALL,
+)
+
+
+class FilterError(ValueError):
+    """A filter argument that doesn't parse, or whose value is unusable."""
+
+
+def _split_token(token: str):
+    """(attr, op, raw_value) if `token` is structurally `attr<op>...` with a
+    known attribute, else None. Purely structural - no value coercion."""
+    match = _FILTER_RE.match(token)
+    if match is None or match.group("attr") not in FILTERABLE_ATTRS:
+        return None
+    return match.group("attr"), match.group("op"), match.group("value")
+
+
+def _coerce(attr: str, raw: str):
+    if attr in _INT_ATTRS:
+        return int(raw)
+    if attr in _BOOL_ATTRS:
+        return str(raw).strip().lower() in ("true", "1", "yes")
+    if attr in _DATE_ATTRS:
+        return datetime.strptime(raw.strip(), _DATE_FORMAT).date()
+    return raw  # string: compared with fnmatch (=) or lexically (< >)
+
+
+@dataclass
+class FilterExpr:
+    attr: str
+    op: str
+    value: object
+
+    def matches(self, item) -> bool:
+        return _compare(self.op, _item_value(item, self.attr), self.value)
+
+
+def _item_value(item, attr):
+    value = getattr(item, attr, None)
+    if attr in _DATE_ATTRS and value is not None:
+        return value.date()  # drop the time component for date comparisons
+    return value
+
+
+def _compare(op: str, actual, expected) -> bool:
+    if op == "=":
+        if isinstance(expected, str):
+            return fnmatch.fnmatch("" if actual is None else str(actual), expected)
+        return actual == expected
+    if actual is None:
+        return False  # None has no ordering
+    try:
+        if op == ">":
+            return actual > expected
+        if op == "<":
+            return actual < expected
+        if op == ">=":
+            return actual >= expected
+        if op == "<=":
+            return actual <= expected
+    except TypeError:
+        return False
+    return False
+
+
+def looks_like_filters(tokens) -> bool:
+    """True when `show`'s arguments should be treated as a filter query rather
+    than a single id / name target."""
+    return bool(tokens) and any(_split_token(t) is not None for t in tokens)
+
+
+def parse_filters(tokens) -> list[FilterExpr]:
+    """All tokens -> FilterExprs. Raises FilterError on the first token that
+    isn't a valid `attr<op>value`."""
+    exprs = []
+    for token in tokens:
+        parts = _split_token(token)
+        if parts is None:
+            raise FilterError(
+                f"'{token}' is not a valid filter - expected attr=value, "
+                f"attr>value, etc. (attributes: {', '.join(sorted(FILTERABLE_ATTRS))})"
+            )
+        attr, op, raw = parts
+        try:
+            value = _coerce(attr, raw)
+        except (ValueError, TypeError):
+            raise FilterError(f"'{raw}' is not a valid value for '{attr}'")
+        exprs.append(FilterExpr(attr, op, value))
+    return exprs
+
+
+def match_items(db, exprs) -> set:
+    """Ids of the items that satisfy every filter."""
+    matched = set()
+    for item_id in db.get_item_ids():
+        item = db.get_item(item_id)
+        if all(expr.matches(item) for expr in exprs):
+            matched.add(item_id)
+    return matched
+
+
+def with_ancestors(db, ids) -> set:
+    """`ids` plus every ancestor of every id, so the selection is a set of
+    complete root-to-node paths."""
+    keep = set()
+    for id_ in ids:
+        cursor = id_
+        while cursor is not None and cursor not in keep:
+            keep.add(cursor)
+            try:
+                cursor = db.get_item_attr(cursor, "parent_id")
+            except DatabaseError:
+                break
+    return keep

{taskai_cli-1.7.0 → taskai_cli-1.8.0}/taskai/help_menu.py

@@ -12,6 +12,10 @@ Viewing:
 'task show all' --> show every item, with ids prepended, as a tree
 'task show {id}' --> show full details for the item with that id
 'task show {name|fnmatch pattern}' --> match an item by name (or glob pattern) and show it
+'task show {attr}{op}{value} ...' --> show only items matching every filter, each with its parent chain for context
+  ops: = > < >= <= ; text uses = with fnmatch (name=Write*), the rest compare numbers/dates
+  no spaces around the operator; quote each expression so your shell doesn't treat > < as redirects
+  e.g. task show 'status=IN PROGRESS' 'priority>=2' 'due_by<12-31-2026'
 
 Creating:
 'task create {name} {--field value ...}' --> create a new top-level (root) item - use this when there's no existing parent to attach to

{taskai_cli-1.7.0 → taskai_cli-1.8.0}/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.8.0}/taskai/static/console.js

@@ -151,6 +151,15 @@ consoleInput.addEventListener("keydown", async (e) => {
 
 		applyTree(data.tree);
 
+		// `show <attr><op><value> ...` — server returns a pruned tree + a flag
+		if (data.filtered) {
+			selectedNode = rootNode;
+			if (typeof onNodeSelected === "function") onNodeSelected(null);
+			fitAll();
+			if (data.output) appendLine(data.output);
+			return;
+		}
+
 		if (data.focus) {
 			const node = nodes.find(n => n.id === String(data.focus));
 			if (node) {

{taskai_cli-1.7.0 → taskai_cli-1.8.0}/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.8.0}/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,
 	},

{taskai_cli-1.7.0 → taskai_cli-1.8.0}/taskai/views.py

@@ -35,14 +35,20 @@ VALID_ATTRS = {
 @config("DISPLAY_STRING", "display_str")
 @config("DISPLAY_COLORS", "display_colors")
 def view_lists(
-        db: JsonDirectoryDatabase, 
-        roots: list[int], 
+        db: JsonDirectoryDatabase,
+        roots: list[int],
         show_done=True,
         max_level=1000,
-        display_str: str = "id name status", 
+        only_ids: set[int] | None = None,
+        display_str: str = "id name status",
         display_colors: str = None
 ):
-    """Shows all the lists"""
+    """Shows all the lists.
+
+    `only_ids`, when given, prunes the walk to just those ids - used by
+    `task show <filters>` to render matched items with their parent chain
+    and nothing else.
+    """
 
     attrs = display_str.lower().split(" ")
 
@@ -77,16 +83,20 @@ def view_lists(
     def _recursive_print(item_id: int, level: int):
         if level >= max_level:
             return
+        if only_ids is not None and item_id not in only_ids:
+            return
 
         try:
             item = db.get_item(item_id)
         except DatabaseError:
             return
-        
+
         _print_item(item, level)
 
 
         for linked_id in item.linked_ids:
+            if only_ids is not None and linked_id not in only_ids:
+                continue
             try:
                 linked_item = db.get_item(linked_id)
             except DatabaseError: