pyworklog 0.3.0__py3-none-any.whl

worklog/commands/__init__.py

@@ -0,0 +1,89 @@
+"""worklog command handlers and their internal helpers.
+
+Split into 5 groups by responsibility: state mutations, queries / views,
+tree / day rendering, bulk import-apply, and meta (init/config/migrate/
+checkin/sched/dateinfo/themes/goal/recap). Each group is one .py file;
+this __init__ re-exports everything so cli.py (and tests) can import
+from `worklog.commands` without knowing the internal split.
+"""
+from .state import (
+    cmd_add,
+    cmd_log,
+    cmd_done,
+    cmd_defer,
+    cmd_start,
+    cmd_stop,
+    cmd_spent,
+    cmd_link,
+    cmd_set,
+    cmd_tick,
+    cmd_wait,
+    cmd_reopen,
+    cmd_cancel,
+    cmd_unlog,
+    cmd_relog,
+    cmd_active,
+    _ids_list,
+    _bulk_status_change,
+    _edit_in_editor,
+)
+from .query import (
+    cmd_show,
+    cmd_ls,
+    cmd_find,
+    cmd_focus,
+    cmd_ancestors,
+    cmd_descendants,
+    cmd_projects,
+    cmd_changes,
+    cmd_summary,
+    cmd_logs,
+    _show_one,
+)
+from .views import (
+    cmd_tree,
+    cmd_day,
+    _tree_by,
+    _tree_children,
+    _print_tree,
+    _print_day_activity,
+    _print_default_tree,
+    _render_day_group,
+    _sec_sort_key,
+    _sched_fires,
+    _scheduled_node_ids,
+    _date_label,
+    _cn_weekday,
+)
+from .bulk import (
+    cmd_import,
+    cmd_apply,
+    _import_node,
+    _import_update,
+    _parse_node_line,
+    _parse_fieldop,
+    _parse_wld,
+    _validate_fieldop,
+    _exec_update,
+    _fieldop_desc,
+    _apply_sub,
+)
+from .meta import (
+    cmd_init,
+    cmd_config,
+    cmd_migrate,
+    cmd_themes,
+    cmd_dateinfo,
+    cmd_goal,
+    cmd_summary_prop,
+    cmd_checkin,
+    cmd_sched,
+    _set_prop,
+    _get_prop,
+    _ensure_today_day,
+    _checkin_collect,
+    _is_interactive_tty,
+    _multi_select_tty,
+    _checkin_per_item,
+    _norm_rrule,
+)

worklog/commands/bulk.py

@@ -0,0 +1,512 @@
+"""worklog commands: bulk group."""
+from __future__ import annotations
+
+import argparse
+import json
+import os
+import re
+import sqlite3
+import sys
+from datetime import datetime, timedelta
+from pathlib import Path
+
+from .. import render
+from ..helpers import (
+    _apply_top_limit,
+    _fmt_dur,
+    _is_brief,
+    _log_full,
+    _norm_sched,
+    _resolve_at_ts,
+    _resolve_concrete_date,
+    _resolve_log_tail,
+    _resolve_window,
+    _sched_anchor,
+    _sched_display,
+    _sched_kind,
+    _sched_sort_key,
+    _status_marker,
+    _term_width,
+    _truncate_log_body,
+    GENERIC_TAGS,
+)
+from ..queries import (
+    _ancestors_chain,
+    _check_ids_exist,
+    _collect_descendants,
+    _has_tag,
+    _insert_log,
+    _node_bucket,
+    _node_clock_min,
+    _node_exists,
+    _node_plan,
+    _node_project,
+    _node_tags,
+    _project_members,
+    _sec_group,
+    _status_filter_sql,
+    _upsert_prop,
+)
+from ..render import (
+    _PRI_STYLE,
+    _STATUS_STYLE,
+    _RICH_AVAIL,
+    _resolve_theme,
+    THEMES,
+    _c,
+    _hl,
+    _node_line,
+    _print_truncation_hint,
+    _snippet,
+    out,
+)
+from ..xdg import _resolve_db_path, _resolve_aliases_path, _xdg_data_home, _xdg_config_home
+
+# Lazy access to cli module (for DB wrappers + module state).
+# Used at function call time (not at import) to avoid the cli ↔ commands
+# import cycle.
+from .. import cli as _cli  # noqa: E402
+
+
+def cmd_import(args, con):
+    """Batch add/update: JSON {add:[...], update:[...]}; single transaction; supports nested children + ref/parent_ref."""
+    import json
+
+    raw = sys.stdin.read() if args.file == "-" else Path(args.file).read_text(encoding="utf-8")
+    try:
+        data = json.loads(raw)
+    except json.JSONDecodeError as e:
+        sys.exit(f"✗ JSON parse error: {e}")
+    if not isinstance(data, dict):
+        sys.exit("✗ top level must be an object {add:[...], update:[...]}")
+
+    ref_map = {}
+    counters = {"add": 0, "update": 0}
+    dry = args.dry_run
+    try:
+        for spec in data.get("add", []):
+            _import_node(con, spec, None, ref_map, dry, counters)
+        for spec in data.get("update", []):
+            _import_update(con, spec, dry, counters)
+    except (ValueError, KeyError) as e:
+        con.rollback()
+        sys.exit(f"✗ import failed (rolled back): {e}")
+
+    if dry:
+        out(_c("[dry-run]", "meta") + _c(f" would add {counters['add']} · update {counters['update']} (not written)"))
+        if ref_map:
+            out("  " + _c("ref: " + ", ".join(ref_map.keys()), "meta"))
+    else:
+        con.commit()
+        out(_c("✓", "done") + _c(f" added {counters['add']} · updated {counters['update']}"))
+        if ref_map:
+            print("  ref->id: " + ", ".join(f"{k}=#{v}" for k, v in ref_map.items()))
+
+
+# --- wl-diff format (apply) ---
+# line format: <prefix><indent><node line>  prefix: '+' add, '~' update, '-' delete, ' ' context anchor
+# node line: [marker] [#pri] #id [kind] title :tags:   (marker required, others optional)
+# rich-field sub-lines: <indent>@log/@link/@prop <value>  (attached to the previous node)
+_MARKER_STATUS = {" ": "TODO", "x": "DONE", "/": "DOING", ">": "LATER", "?": "WAIT", "-": "CANCELED"}
+
+def cmd_apply(args, con):
+    """Apply wl-diff: + add (node line) / ~ update (lock-line + field-ops, only declared fields) / - delete / anchor. Single transaction + dry-run validation."""
+    raw = sys.stdin.read() if args.file == "-" else Path(args.file).read_text(encoding="utf-8")
+    try:
+        ops = _parse_wld(raw)
+    except ValueError as e:
+        sys.exit(f"✗ parse failed: {e}")
+
+    # --- validation phase (validate all, stop on errors, no write) ---
+    errors = []
+    for o in ops:
+        pfx, ln = o["op"], o["lineno"]
+        if pfx == "~":
+            if not _node_exists(con, o["id"]):
+                errors.append(f"line {ln}: #{o['id']} does not exist")
+            if not o["fieldops"]:
+                errors.append(f"line {ln}: ~ #{o['id']} has no field operations")
+            for floln, (action, field, value) in o["fieldops"]:
+                _validate_fieldop(con, floln, action, field, value, errors)
+        else:
+            f = o["fields"]
+            has_id = "id" in f
+            if pfx in ("-", " ") and not has_id:
+                errors.append(f"line {ln}: '{pfx}' requires #id")
+            if pfx == "+" and has_id:
+                errors.append(f"line {ln}: '+' add should not carry #id")
+            if has_id and pfx != "+" and not _node_exists(con, f["id"]):
+                errors.append(f"line {ln}: #{f['id']} does not exist")
+            if "marker" in f and f["marker"] not in _MARKER_STATUS:
+                errors.append(f"line {ln}: unknown marker [{f['marker']}]")
+    if errors:
+        sys.exit("✗ validation failed (not written):\n  " + "\n  ".join(errors))
+
+    # --- plan (guaranteed valid at this point) ---
+    plan = []
+    for o in ops:
+        pfx = o["op"]
+        if pfx == "~":
+            ch = ", ".join(_fieldop_desc(a, fld, v) for _, (a, fld, v) in o["fieldops"])
+            plan.append(f"~ #{o['id']}: {ch}")
+        elif pfx == "+":
+            f = o["fields"]
+            sub = f" (+{len(o['subs'])} sub-items)" if o["subs"] else ""
+            plan.append(f"+ {f['title']}" + (f" @depth{o['depth']}" if o["depth"] else "") + sub)
+        elif pfx == "-":
+            plan.append(f"- #{o['fields']['id']} (cascades subtree)")
+
+    if args.dry_run:
+        out(_c("[dry-run]", "meta") + _c(f" {len(plan)} operations (not written):", "header"))
+        for desc in plan:
+            out("  " + _c(desc))
+        return
+
+    # --- execute (single transaction) ---
+    stack = {}
+    counts = {"add": 0, "update": 0, "delete": 0}
+    try:
+        for o in ops:
+            pfx = o["op"]
+            if pfx == "~":
+                _exec_update(con, o)
+                counts["update"] += 1
+                continue
+            f, depth = o["fields"], o["depth"]
+            if pfx == " ":
+                stack[depth] = f["id"]
+                continue
+            if pfx == "-":
+                # recursive subtree delete: node self-ref is ON DELETE SET NULL, only deleting the parent would orphan children, so we must explicitly collect descendants
+                ids = [f["id"]] + _collect_descendants(con, f["id"])
+                for did in ids:
+                    con.execute("DELETE FROM node WHERE id = ?", (did,))
+                counts["delete"] += len(ids)
+                continue
+            # pfx == "+": add new node
+            parent_id = stack.get(depth - 1) if depth > 0 else None
+            status = _MARKER_STATUS.get(f.get("marker", " "), "TODO")
+            kind = f.get("kind", "task")
+            if status == "DONE":
+                cur = con.execute(
+                    "INSERT INTO node (parent_id,title,kind,status,priority,closed_at) "
+                    "VALUES (?,?,?,?,?, datetime('now','localtime'))",
+                    (parent_id, f["title"], kind, status, f.get("priority")),
+                )
+            else:
+                cur = con.execute(
+                    "INSERT INTO node (parent_id,title,kind,status,priority) VALUES (?,?,?,?,?)",
+                    (parent_id, f["title"], kind, status, f.get("priority")),
+                )
+            nid = cur.lastrowid
+            for t in f.get("tags", []):
+                con.execute("INSERT OR IGNORE INTO tag (node_id,tag) VALUES (?,?)", (nid, t))
+            for kind_, val in o["subs"]:
+                _apply_sub(con, nid, kind_, val)
+            counts["add"] += 1
+            stack[depth] = nid
+    except Exception as e:
+        con.rollback()
+        sys.exit(f"✗ apply failed (rolled back): {e}")
+
+    con.commit()
+    out(_c("✓", "done") + _c(f" added {counts['add']} · updated {counts['update']} · deleted {counts['delete']}"))
+
+def _import_node(con, spec, parent_id, ref_map, dry, counters):
+    """Recursively insert a node (with tags/props/links/logs/children). Returns new id (placeholder None in dry mode)."""
+    title = spec.get("title")
+    if not title:
+        raise ValueError(f"node missing title: {spec}")
+    kind = spec.get("kind", "task")
+    status = spec.get("status")
+    if not status and kind in ("task", "habit"):
+        status = "TODO"
+    sched = _norm_sched(spec.get("scheduled"))  # normalize + validate (raises in dry-run)
+    # parent: explicit parent_id > parent_ref (same batch) > recursively-passed parent_id
+    pid = spec.get("parent", parent_id)
+    if spec.get("parent_ref"):
+        if spec["parent_ref"] not in ref_map:
+            raise ValueError(f"parent_ref '{spec['parent_ref']}' undefined (must appear before reference)")
+        pid = ref_map[spec["parent_ref"]]
+    closed_at = None
+    if status == "DONE":
+        closed_at = "datetime_now"  # placeholder; the SQL below uses datetime('now','localtime')
+
+    if dry:
+        nid = f"<ref:{spec.get('ref', '?')}>"
+        counters["add"] += 1
+    else:
+        if closed_at:
+            cur = con.execute(
+                "INSERT INTO node (parent_id,title,kind,status,priority,scheduled_at,deadline_at,body,closed_at) "
+                "VALUES (?,?,?,?,?,?,?,?, datetime('now','localtime'))",
+                (pid, title, kind, status, spec.get("priority"), sched,
+                 spec.get("deadline"), spec.get("body")),
+            )
+        else:
+            cur = con.execute(
+                "INSERT INTO node (parent_id,title,kind,status,priority,scheduled_at,deadline_at,body) "
+                "VALUES (?,?,?,?,?,?,?,?)",
+                (pid, title, kind, status, spec.get("priority"), sched,
+                 spec.get("deadline"), spec.get("body")),
+            )
+        nid = cur.lastrowid
+        counters["add"] += 1
+        for t in spec.get("tags", []):
+            con.execute("INSERT OR IGNORE INTO tag (node_id,tag) VALUES (?,?)", (nid, t))
+        for k, v in (spec.get("props") or {}).items():
+            _upsert_prop(con, nid, k, str(v))
+        for d in spec.get("links", []):
+            con.execute("INSERT OR IGNORE INTO link (node_id,vault_doc) VALUES (?,?)", (nid, d))
+        for entry in spec.get("logs", []):
+            _insert_log(con, nid, entry)
+
+    if spec.get("ref"):
+        ref_map[spec["ref"]] = nid
+    for child in spec.get("children", []):
+        _import_node(con, child, nid, ref_map, dry, counters)
+    return nid
+
+def _import_update(con, spec, dry, counters):
+    nid = spec.get("id")
+    if not nid or not _node_exists(con, nid):
+        raise ValueError(f"update target #{nid} does not exist")
+    if dry:
+        counters["update"] += 1
+        return
+    if "parent" in spec and spec["parent"] is not None and not _node_exists(con, spec["parent"]):
+        raise ValueError(f"update #{nid}: parent #{spec['parent']} does not exist")
+    fields, vals = [], []
+    for col in ("status", "priority", "title", "scheduled_at", "deadline_at", "body"):
+        if col in spec:
+            fields.append(f"{col} = ?")
+            vals.append(spec[col])
+    if "parent" in spec:  # move; parent_id column name differs from spec key, handled separately
+        fields.append("parent_id = ?")
+        vals.append(spec["parent"])
+    if spec.get("status") == "DONE" and "closed_at" not in spec:
+        fields.append("closed_at = datetime('now','localtime')")
+    if fields:
+        con.execute(f"UPDATE node SET {', '.join(fields)} WHERE id = ?", (*vals, nid))
+    for t in spec.get("add_tags", []):
+        con.execute("INSERT OR IGNORE INTO tag (node_id,tag) VALUES (?,?)", (nid, t))
+    for t in spec.get("remove_tags", []):
+        con.execute("DELETE FROM tag WHERE node_id = ? AND tag = ?", (nid, t))
+    for d in spec.get("add_links", []):
+        con.execute("INSERT OR IGNORE INTO link (node_id,vault_doc) VALUES (?,?)", (nid, d))
+    for entry in spec.get("add_logs", []):
+        _insert_log(con, nid, entry)
+    counters["update"] += 1
+
+def _parse_node_line(body):
+    import re
+
+    f = {}
+    m = re.match(r"^\[([ x/>?\-])\]\s*", body)
+    if m:
+        f["marker"] = m.group(1)
+        body = body[m.end():]
+    m = re.match(r"^\[#([A-C])\]\s*", body)
+    if m:
+        f["priority"] = m.group(1)
+        body = body[m.end():]
+    m = re.match(r"^#(\d+)\s*", body)
+    if m:
+        f["id"] = int(m.group(1))
+        body = body[m.end():]
+    m = re.match(r"^\[([a-z_]+)\]\s*", body)
+    if m:
+        f["kind"] = m.group(1)
+        body = body[m.end():]
+    m = re.search(r"\s*:([\w:]+):\s*$", body)
+    if m:
+        f["tags"] = [t for t in m.group(1).split(":") if t]
+        body = body[: m.start()]
+    f["title"] = body.strip()
+    return f
+
+
+_SETTABLE = ("status", "priority", "title", "parent", "scheduled", "deadline")
+
+def _parse_fieldop(s):
+    """Parse a field-operation line under a ~ block. Returns (action, field, value) or None.
+
+    set:   `status DONE` / `priority A` / `title x` / `parent 6` / `scheduled 2026-06-01`
+    clear: `priority -` (value '-' clears)
+    tag:   `+tag x` / `-tag x`
+    log:   `+log text` (add only; log is append-only)
+    link:  `+link doc` / `-link doc`
+    prop:  `prop k=v` / `-prop k`
+    """
+    import re
+
+    m = re.match(r"^([+-])(tag|link)\s+(.+)$", s)
+    if m:
+        return ("add" if m.group(1) == "+" else "remove", m.group(2), m.group(3).strip())
+    m = re.match(r"^\+log\s+(.+)$", s)
+    if m:
+        return ("add", "log", m.group(1).strip())
+    m = re.match(r"^-prop\s+(\S+)$", s)
+    if m:
+        return ("remove", "prop", m.group(1))
+    m = re.match(r"^prop\s+(\S+?)=(.*)$", s)
+    if m:
+        return ("set", "prop", (m.group(1), m.group(2).strip()))
+    m = re.match(r"^(" + "|".join(_SETTABLE) + r")\s+(.+)$", s)
+    if m:
+        val = m.group(2).strip()
+        if val == "-":
+            return ("clear", m.group(1), None)
+        return ("set", m.group(1), val)
+    return None
+
+def _parse_wld(text):
+    """Parse wl-diff -> ops list.
+
+    +/-/anchor op: {op,depth,fields,subs,lineno}
+    ~  op:         {op:'~',id,fieldops:[(lineno,(action,field,value))],lineno}
+    raises ValueError
+    """
+    import re
+
+    ops = []
+    cur_update = None  # most recent ~ op; collects subsequent indented field-op lines
+    for lineno, raw in enumerate(text.splitlines(), 1):
+        s = raw.lstrip()
+        # blank / comment ('#' followed by space or non-digit) -> skip; but #<digit> is a node id, not a comment
+        if not s or (s.startswith("#") and (len(s) == 1 or not s[1].isdigit())):
+            continue
+        indented = raw[:1] in (" ", "\t")
+        # indented line under a ~ context: try field-op first (+tag/-tag/-prop start with +/-, so first-char heuristic isn't enough)
+        if cur_update is not None and indented:
+            fop = _parse_fieldop(s)
+            if fop is not None:
+                cur_update["fieldops"].append((lineno, fop))
+                continue
+            # indented but not a valid field-op: if it looks like a node line (has marker), drop through as new node (ending ~); else error
+            if not re.match(r"^[+\- ]?\s*\[", s):
+                raise ValueError(f"line {lineno}: unparseable field-op '{s}' under '~' (allowed: status/priority/title/parent/scheduled/deadline/±tag/+log/±link/prop/-prop)")
+        # @ sub-line (rich fields of a +/-/anchor node)
+        m = re.match(r"^[+\- ]?\s*@(log|link|prop)\s+(.*)$", raw)
+        if m:
+            if not ops or ops[-1]["op"] == "~":
+                raise ValueError(f"line {lineno}: @{m.group(1)} has no preceding +/anchor node to attach to")
+            ops[-1]["subs"].append((m.group(1), m.group(2).strip()))
+            continue
+        m = re.match(r"^([+~\- ])(\s*)(.*)$", raw)
+        if not m:
+            raise ValueError(f"line {lineno}: cannot parse '{raw}'")
+        prefix, spaces, body = m.group(1), m.group(2), m.group(3)
+        if not body.strip():
+            continue
+        if prefix == "~":
+            idm = re.search(r"#(\d+)", body)
+            if not idm:
+                raise ValueError(f"line {lineno}: '~' requires #id (e.g. '~ #14' or single-line '~ [x] #14')")
+            nid = int(idm.group(1))
+            # single-line shorthand: parse marker/priority/title if present -> a set op for each (untouched if absent)
+            f = _parse_node_line(body)
+            inline = []
+            if "marker" in f:
+                inline.append((lineno, ("set", "status", _MARKER_STATUS.get(f["marker"], "TODO"))))
+            if "priority" in f:
+                inline.append((lineno, ("set", "priority", f["priority"])))
+            if f.get("title"):
+                inline.append((lineno, ("set", "title", f["title"])))
+            op = {"op": "~", "id": nid, "fieldops": inline, "lineno": lineno}
+            ops.append(op)
+            cur_update = op  # may still accept subsequent indented field-ops (mix of single-line shorthand + complex ops)
+            continue
+        cur_update = None  # +/-/anchor line ends ~ context
+        depth = len(spaces) // 2
+        fields = _parse_node_line(body)
+        if not fields["title"] and prefix != "-":
+            raise ValueError(f"line {lineno}: missing title")
+        ops.append({"op": prefix, "depth": depth, "fields": fields, "subs": [], "lineno": lineno})
+    return ops
+
+
+_STATUSES = {"TODO", "DOING", "LATER", "WAIT", "DONE", "DEFERRED", "CANCELED"}
+_SET_COL = {"status": "status", "priority": "priority", "title": "title",
+            "parent": "parent_id", "scheduled": "scheduled_at", "deadline": "deadline_at"}
+
+def _validate_fieldop(con, lineno, action, field, value, errs):
+    if field == "status" and action == "set" and value not in _STATUSES:
+        errs.append(f"line {lineno}: invalid status '{value}' (valid: {'/'.join(sorted(_STATUSES))})")
+    elif field == "priority" and action == "set" and value not in ("A", "B", "C"):
+        errs.append(f"line {lineno}: invalid priority '{value}' (A/B/C)")
+    elif field == "title" and action == "clear":
+        errs.append(f"line {lineno}: title cannot be cleared")
+    elif field == "parent" and action == "set":
+        if not value.isdigit() or not _node_exists(con, int(value)):
+            errs.append(f"line {lineno}: parent #{value} does not exist")
+    elif field == "scheduled" and action == "set":
+        try:
+            _norm_sched(value)
+        except ValueError as e:
+            errs.append(f"line {lineno}: {e}")
+
+def _exec_update(con, o):
+    """Execute ~ field operations: only touches explicitly-declared fields; never touches anything not declared."""
+    nid = o["id"]
+    for _, (action, field, value) in o["fieldops"]:
+        if field in _SET_COL:
+            col = _SET_COL[field]
+            if action == "clear":
+                con.execute(f"UPDATE node SET {col} = NULL WHERE id = ?", (nid,))
+            else:
+                if field == "parent":
+                    v = int(value)
+                elif field == "scheduled":
+                    v = _norm_sched(value)
+                else:
+                    v = value
+                con.execute(f"UPDATE node SET {col} = ? WHERE id = ?", (v, nid))
+                if field == "status" and value == "DONE":
+                    con.execute("UPDATE node SET closed_at = datetime('now','localtime') WHERE id = ? AND closed_at IS NULL", (nid,))
+        elif field == "tag":
+            if action == "add":
+                con.execute("INSERT OR IGNORE INTO tag (node_id,tag) VALUES (?,?)", (nid, value))
+            else:
+                con.execute("DELETE FROM tag WHERE node_id = ? AND tag = ?", (nid, value))
+        elif field == "log":
+            _insert_log(con, nid, value)
+        elif field == "link":
+            if action == "add":
+                con.execute("INSERT OR IGNORE INTO link (node_id,vault_doc) VALUES (?,?)", (nid, value))
+            else:
+                con.execute("DELETE FROM link WHERE node_id = ? AND vault_doc = ?", (nid, value))
+        elif field == "prop":
+            if action == "set":
+                k, v = value
+                _upsert_prop(con, nid, k, v)
+            else:
+                con.execute("DELETE FROM prop WHERE node_id = ? AND key = ?", (nid, value))
+
+def _fieldop_desc(action, field, value):
+    if action == "clear":
+        return f"{field}=cleared"
+    if action == "add":
+        return f"+{field} {value}"
+    if action == "remove":
+        return f"-{field} {value}"
+    if field == "prop":
+        return f"prop {value[0]}={value[1]}"
+    return f"{field}->{value}"
+
+def _apply_sub(con, nid, kind, val):
+    if kind == "log":
+        _insert_log(con, nid, val)
+    elif kind == "link":
+        con.execute("INSERT OR IGNORE INTO link (node_id,vault_doc) VALUES (?,?)", (nid, val))
+    elif kind == "prop":
+        if "=" in val:
+            k, v = val.split("=", 1)
+            _upsert_prop(con, nid, k.strip(), v.strip())
+
+
+
+_VALID_FIND_FIELDS = {"title", "body", "log", "tag", "prop", "link"}
+_VALID_KINDS = {"task", "project", "area", "year", "quarter", "month", "week", "day",
+                "lifetime", "decade", "habit", "signal", "meetlog"}
+