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

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

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

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

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

{taskai_cli-1.7.1 → taskai_cli-1.8.1}/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
@@ -57,6 +81,25 @@ def get_tree():
 
 class CommandRequest(BaseModel):
     input: str
+    # raw filter args from the last `show <attr><op>value ...` the frontend
+    # ran, if any — so a mutation's refreshed tree stays scoped to that view
+    # instead of snapping back to the whole forest
+    filter: str | None = None
+
+
+def _response_tree(filter_str):
+    """The tree a mutation should return: pruned to `filter_str`'s matches
+    (+ their parent chains) when one is active, else the whole forest."""
+    if not filter_str:
+        return _full_tree()
+    tokens = _parse_arg_string(filter_str)
+    if not looks_like_filters(tokens):
+        return _full_tree()
+    try:
+        exprs = parse_filters(tokens)
+    except FilterError:
+        return _full_tree()
+    return _filtered_tree(with_ancestors(db, match_items(db, exprs)))
 
 
 @app.post("/api/command")
@@ -65,7 +108,7 @@ def run_command(request: CommandRequest):
     args, kwargs = _parse_remaining(arg_parts)
 
     if not args:
-        return {"output": "", "tree": _full_tree(), "focus": None}
+        return {"output": "", "tree": _response_tree(request.filter), "focus": None}
 
     if args[0] == "show":
         return _run_show(args)
@@ -77,12 +120,17 @@ def run_command(request: CommandRequest):
     except TaskCLIError:
         pass  # Controller.throw_error() already printed the error into `output`
 
-    return {"output": output.getvalue(), "tree": _full_tree(), "focus": None}
+    return {"output": output.getvalue(), "tree": _response_tree(request.filter), "focus": None}
 
 
 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 +148,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.1 → taskai_cli-1.8.1}/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.1/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.1 → taskai_cli-1.8.1}/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.1 → taskai_cli-1.8.1}/taskai/static/canvas.js

@@ -403,7 +403,9 @@ function fitAll(duration = STYLE.zoom.focusDurationMs) {
 
 	const pad = 60; // screen px of breathing room around the content
 	const scale = Math.min(
-		STYLE.zoom.max,
+		// don't auto-zoom in past the focus threshold — a small subset
+		// shouldn't fill the screen; the user can still wheel in past this
+		STYLE.zoom.focusScale,
 		Math.max(
 			STYLE.zoom.min,
 			Math.min(
@@ -741,10 +743,13 @@ canvas.addEventListener("dblclick", (e) => {
 	const rect = canvas.getBoundingClientRect();
 	const { x, y } = screenToWorld(e.clientX - rect.left, e.clientY - rect.top);
 	const clicked = nodes.find(node => hitTest(node, x, y));
+	if (!clicked) return;
 
-	if (clicked) {
-		focusOnNode(clicked);
-	}
+	// single click already selected it; double click also opens the editor
+	selectedNode = clicked;
+	if (typeof onNodeSelected === "function") onNodeSelected(itemForNode(clicked));
+	if (typeof openEditPanel === "function") openEditPanel();
+	focusOnNode(clicked); // after openEditPanel so the ease tracks the narrowed canvas
 })
 
 canvas.addEventListener("mousedown", (e) => {

{taskai_cli-1.7.1 → taskai_cli-1.8.1}/taskai/static/console.js

@@ -29,6 +29,12 @@ function appendLine(text) {
 	consoleScrollback.scrollTop = consoleScrollback.scrollHeight;
 }
 
+// raw filter args from the last `show <attr><op>value ...` query (e.g.
+// `priority>3 status="IN PROGRESS"`), or null. Sent with every /api/command
+// POST so a mutation's refreshed tree stays scoped to the same filtered view.
+// Cleared by `show all` and by navigating to a specific node.
+let activeFilter = null;
+
 const PAN_AMOUNT = 250; // screen pixels per pan command
 const ZOOM_FACTOR = 1.5;
 
@@ -62,10 +68,12 @@ function resolveDotRefs(command) {
 // POST a raw command string to the shared endpoint; returns the parsed
 // { output, tree, focus } (or throws). Callers decide what to echo.
 async function postCommand(input) {
+	const body = { input };
+	if (activeFilter) body.filter = activeFilter;
 	const res = await fetch("/api/command", {
 		method: "POST",
 		headers: { "Content-Type": "application/json" },
-		body: JSON.stringify({ input }),
+		body: JSON.stringify(body),
 	});
 	return res.json();
 }
@@ -82,6 +90,7 @@ async function showAll() {
 		return;
 	}
 	applyTree(tree);
+	activeFilter = null; // `show all` drops any filter
 	selectedNode = rootNode;
 	if (typeof onNodeSelected === "function") onNodeSelected(null);
 	fitAll();
@@ -151,7 +160,18 @@ consoleInput.addEventListener("keydown", async (e) => {
 
 		applyTree(data.tree);
 
+		// `show <attr><op><value> ...` — server returns a pruned tree + a flag
+		if (data.filtered) {
+			activeFilter = target; // remember it so mutations keep this view
+			selectedNode = rootNode;
+			if (typeof onNodeSelected === "function") onNodeSelected(null);
+			fitAll();
+			if (data.output) appendLine(data.output);
+			return;
+		}
+
 		if (data.focus) {
+			activeFilter = null; // navigated to a specific node — no longer filtered
 			const node = nodes.find(n => n.id === String(data.focus));
 			if (node) {
 				selectedNode = node;
@@ -199,12 +219,7 @@ consoleInput.addEventListener("keydown", async (e) => {
 
 	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();
+		data = await postCommand(command);
 	} catch (err) {
 		appendLine("Error: " + err.message);
 		return;

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

@@ -64,12 +64,7 @@ async function sendFieldUpdate(item, def, value) {
 
 	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();
+		data = await postCommand(command); // carries the active filter, if any
 	} catch (err) {
 		appendLine(`Error updating item ${item.id}: ${err.message}`);
 		return;
@@ -87,12 +82,7 @@ async function sendComment(itemId, 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();
+		data = await postCommand(command); // carries the active filter, if any
 	} catch (err) {
 		appendLine(`Error adding comment to item ${itemId}: ${err.message}`);
 		return;

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

@@ -31,10 +31,19 @@ function toggleShortcutPanel(force) {
 shortcutToggle.addEventListener("click", () => toggleShortcutPanel());
 
 function toggleEditPanel() {
-	if (editPanel.classList.contains("expanded")) closeEditPanel();
+	if (editPanel.classList.contains("expanded")) closeEditPanelAndRefocus();
 	else openEditPanel();
 }
 
+// close the edit panel, then ease the selected node back to center as the
+// canvas widens out — without this the panel's width animation re-anchors on
+// the old center and leaves the node cut off at the edge
+function closeEditPanelAndRefocus() {
+	closeEditPanel();
+	const node = selectedRealNode();
+	if (node) focusOnNode(node);
+}
+
 // --- action helpers --------------------------------------------------------
 
 // the selected node, or null when the selection is the synthetic root
@@ -69,9 +78,6 @@ function toggleDoneSelected() {
 function deleteSelected() {
 	const node = selectedRealNode();
 	if (!node) return;
-	const item = itemForNode(node);
-	const label = item ? item.name : node.id;
-	if (!window.confirm(`Delete "${label}" and everything under it?`)) return;
 	runMutation(`delete ${node.id}`);
 }
 
@@ -115,6 +121,10 @@ function handleEscape() {
 		el.blur();
 		return;
 	}
+	if (editPanel.classList.contains("expanded")) {
+		closeEditPanelAndRefocus();
+		return;
+	}
 	// deselect, but leave the camera where it is — Esc shouldn't move/zoom
 	selectedNode = rootNode;
 	if (typeof onNodeSelected === "function") onNodeSelected(null);
@@ -130,9 +140,13 @@ const PAN_VEC = { ArrowUp: [0, 1], ArrowDown: [0, -1], ArrowLeft: [1, 0], ArrowR
 const SHORTCUTS = [
 	{ section: "Panels" },
 	{
-		combos: [{ key: "`" }], glyphs: ["`"], desc: "Toggle terminal",
+		combos: [{ key: "`" }, { key: "~" }], glyphs: ["`"], desc: "Terminal (focus / close)",
 		whileTyping: (el) => el === consoleInput, // also closes it from inside
-		run: () => toggleConsole(),
+		run: () => {
+			if (document.activeElement === consoleInput) toggleConsole(false); // close from inside
+			else if (consolePanel.classList.contains("expanded")) consoleInput.focus(); // open but unfocused -> jump in
+			else toggleConsole(true); // closed -> open (focuses input)
+		},
 	},
 	{
 		combos: [{ key: "?" }], glyphs: ["?"], desc: "Toggle this panel",
@@ -185,7 +199,7 @@ const SHORTCUTS = [
 		run: () => toggleDoneSelected(),
 	},
 	{
-		combos: [{ key: "Delete" }], glyphs: ["Del"], desc: "Delete (asks first)",
+		combos: [{ key: "Delete" }], glyphs: ["Del"], desc: "Delete",
 		run: () => deleteSelected(),
 	},
 ];

{taskai_cli-1.7.1 → taskai_cli-1.8.1}/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: