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

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

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

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

{taskai_cli-1.7.1 → 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.1 → 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.1 → 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.1 → 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.1 → 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: