meshcode 2.11.12__tar.gz → 2.11.14__tar.gz

{meshcode-2.11.12 → meshcode-2.11.14}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: meshcode
-Version: 2.11.12
+Version: 2.11.14
 Summary: Real-time communication between AI agents — Supabase-backed CLI
 Author-email: MeshCode <hello@meshcode.io>
 License: MIT

{meshcode-2.11.12 → meshcode-2.11.14}/meshcode/__init__.py

@@ -1,5 +1,5 @@
 """MeshCode — Real-time communication between AI agents."""
-__version__ = "2.11.12"
+__version__ = "2.11.14"
 
 # Exception hierarchy — eagerly imported (lightweight, no deps)
 from meshcode.exceptions import (  # noqa: F401

meshcode-2.11.14/meshcode/date_parse.py

@@ -0,0 +1,154 @@
+"""Natural-language date parsing for `meshcode_task_create(due=...)`.
+
+Goal: accept human inputs ("by Thursday", "in 3 days", "tomorrow",
+"next week", "May 25") and ISO 8601 strict pass-through. No external
+dependency — manual rules keep the install lean.
+
+API:
+    parse_due(text: str, now: datetime|None = None)
+        -> (parsed_dt: datetime|None, label: str)
+
+Returned datetime is timezone-aware UTC. Labels are normalized lowercase
+human strings. Unknown input returns (None, original_text).
+"""
+from __future__ import annotations
+
+import re
+from datetime import datetime, timedelta, timezone
+from typing import Optional, Tuple
+
+_WEEKDAYS = {
+    "monday": 0, "mon": 0,
+    "tuesday": 1, "tue": 1, "tues": 1,
+    "wednesday": 2, "wed": 2,
+    "thursday": 3, "thu": 3, "thur": 3, "thurs": 3,
+    "friday": 4, "fri": 4,
+    "saturday": 5, "sat": 5,
+    "sunday": 6, "sun": 6,
+}
+
+_MONTHS = {
+    "january": 1, "jan": 1,
+    "february": 2, "feb": 2,
+    "march": 3, "mar": 3,
+    "april": 4, "apr": 4,
+    "may": 5,
+    "june": 6, "jun": 6,
+    "july": 7, "jul": 7,
+    "august": 8, "aug": 8,
+    "september": 9, "sep": 9, "sept": 9,
+    "october": 10, "oct": 10,
+    "november": 11, "nov": 11,
+    "december": 12, "dec": 12,
+}
+
+
+def _eod(dt: datetime) -> datetime:
+    """End of day, UTC-aware."""
+    return dt.replace(hour=23, minute=59, second=0, microsecond=0, tzinfo=timezone.utc)
+
+
+def _next_weekday(now: datetime, target_dow: int) -> datetime:
+    """Closest upcoming weekday match (today counts if it's in the future)."""
+    days_ahead = (target_dow - now.weekday()) % 7
+    if days_ahead == 0:
+        # "Thursday" said on Thursday → next Thursday (week out), unless
+        # caller explicitly said "today". Convention: same-day → next week.
+        days_ahead = 7
+    return _eod(now + timedelta(days=days_ahead))
+
+
+def parse_due(text: str, now: Optional[datetime] = None) -> Tuple[Optional[datetime], str]:
+    """Parse a natural-language due-date string. Returns (datetime|None, label).
+
+    The label is what we'll persist as due_label (mig 329) — preserves the
+    user's voice when shown back ("by Thursday" stays human, not "2026-05-21").
+    """
+    if not text:
+        return None, ""
+    raw = text.strip()
+    s = raw.lower()
+    if now is None:
+        now = datetime.now(tz=timezone.utc)
+    elif now.tzinfo is None:
+        now = now.replace(tzinfo=timezone.utc)
+
+    # ISO 8601 strict pass-through (e.g. "2026-05-25T15:00:00Z" or "2026-05-25")
+    try:
+        iso = raw.replace("Z", "+00:00")
+        dt = datetime.fromisoformat(iso)
+        if dt.tzinfo is None:
+            dt = dt.replace(tzinfo=timezone.utc)
+        return dt, raw
+    except ValueError:
+        pass
+
+    # "today" / "tonight"
+    if s in ("today", "eod", "end of day", "tonight"):
+        return _eod(now), raw
+
+    # "tomorrow"
+    if s in ("tomorrow", "tmrw"):
+        return _eod(now + timedelta(days=1)), raw
+
+    # "in N days"|"in N hours"|"in N weeks"
+    m = re.match(r"^in\s+(\d+)\s+(day|days|hour|hours|hr|hrs|week|weeks|wk|wks|minute|minutes|min|mins)$", s)
+    if m:
+        n = int(m.group(1))
+        unit = m.group(2)
+        if unit.startswith("d"):
+            dt = _eod(now + timedelta(days=n))
+        elif unit.startswith("h") or unit.startswith("hr"):
+            dt = now + timedelta(hours=n)
+        elif unit.startswith("w"):
+            dt = _eod(now + timedelta(weeks=n))
+        elif unit.startswith("m"):
+            dt = now + timedelta(minutes=n)
+        else:
+            dt = None
+        return dt, raw
+
+    # "next week"
+    if s in ("next week", "nextweek"):
+        return _eod(now + timedelta(weeks=1)), raw
+
+    # "next <weekday>"
+    m = re.match(r"^next\s+([a-z]+)$", s)
+    if m and m.group(1) in _WEEKDAYS:
+        return _next_weekday(now + timedelta(days=7), _WEEKDAYS[m.group(1)]), raw
+
+    # "by <weekday>" / "<weekday>" / "this <weekday>"
+    m = re.match(r"^(?:by\s+|this\s+)?([a-z]+)$", s)
+    if m and m.group(1) in _WEEKDAYS:
+        return _next_weekday(now, _WEEKDAYS[m.group(1)]), raw
+
+    # "<month> <day>" or "<day> <month>" — assumes current year (or next year
+    # if the date already passed). Examples: "May 25", "25 May", "May 25 2026".
+    m = re.match(r"^(?:by\s+)?([a-z]+)\s+(\d{1,2})(?:[,\s]+(\d{4}))?$", s)
+    if m and m.group(1) in _MONTHS:
+        month = _MONTHS[m.group(1)]
+        day = int(m.group(2))
+        year = int(m.group(3)) if m.group(3) else now.year
+        try:
+            dt = _eod(datetime(year, month, day, tzinfo=timezone.utc))
+            if dt < now and not m.group(3):
+                dt = _eod(datetime(year + 1, month, day, tzinfo=timezone.utc))
+            return dt, raw
+        except ValueError:
+            pass
+
+    m = re.match(r"^(?:by\s+)?(\d{1,2})\s+([a-z]+)(?:[,\s]+(\d{4}))?$", s)
+    if m and m.group(2) in _MONTHS:
+        day = int(m.group(1))
+        month = _MONTHS[m.group(2)]
+        year = int(m.group(3)) if m.group(3) else now.year
+        try:
+            dt = _eod(datetime(year, month, day, tzinfo=timezone.utc))
+            if dt < now and not m.group(3):
+                dt = _eod(datetime(year + 1, month, day, tzinfo=timezone.utc))
+            return dt, raw
+        except ValueError:
+            pass
+
+    # Fallback: not understood. Return None so caller can decide.
+    return None, raw

{meshcode-2.11.12 → meshcode-2.11.14}/meshcode/meshcode_mcp/backend.py

@@ -1190,8 +1190,13 @@ def set_status(project_id: str, agent: str, status: str, task: str = "", api_key
     return {"ok": True, "status": status}
 
 
-def task_create(api_key, project_id, creator_agent, title, description="", assignee="*", priority="normal", parent_task_id=None):
-    return sb_rpc("mc_task_create", {
+def task_create(api_key, project_id, creator_agent, title, description="",
+                assignee="*", priority="normal", parent_task_id=None,
+                goal_id=None, strict=False,
+                due_at=None, due_label=None, depends_on=None):
+    """RPC wrapper. due_at must be an ISO 8601 string or None — the MCP tool
+    layer parses natural-language input via meshcode.date_parse first."""
+    args = {
         "p_api_key": api_key,
         "p_project_id": project_id,
         "p_creator_agent": creator_agent,
@@ -1200,7 +1205,19 @@ def task_create(api_key, project_id, creator_agent, title, description="", assig
         "p_assignee": assignee,
         "p_priority": priority,
         "p_parent_task_id": parent_task_id,
-    })
+        "p_strict": strict,
+        "p_goal_id": goal_id,
+    }
+    # CAL-1/CAL-2: extra fields. Only pass when set so we stay back-compat
+    # with projects where mig 329 isn't applied yet (PostgREST will
+    # 404 on extras when the new signature isn't in the schema cache).
+    if due_at is not None:
+        args["p_due_at"] = due_at
+    if due_label is not None:
+        args["p_due_label"] = due_label
+    if depends_on:
+        args["p_depends_on"] = depends_on
+    return sb_rpc("mc_task_create", args)
 
 
 # Client-side debounce for task_list to neutralize runaway pollers without a

{meshcode-2.11.12 → meshcode-2.11.14}/meshcode/meshcode_mcp/server.py

@@ -3720,6 +3720,11 @@ async def _meshcode_wait_inner(actual_timeout: int, include_acks: bool) -> Dict[
         out["pending_tasks"] = pending_tasks
     else:
         out["no_work"] = True
+    # CAL-3 calendar context — surface due/overdue/next_due on timeouts so the
+    # agent knows whether to nudge work even when no new msg arrived.
+    _ctx = _calendar_context_for_self()
+    if _ctx is not None:
+        out["calendar_context"] = _ctx
     return out
 
 
@@ -3811,9 +3816,53 @@ def meshcode_check(include_acks: bool = False, since: Optional[str] = None, mark
     _hints = be.take_memory_hints()
     if _hints:
         result["memory_hints"] = _hints
+    # CAL-3 calendar context — same shape as meshcode_boot, computed lazily
+    # so the LLM sees due/overdue counts inline with every check/wait return.
+    _ctx = _calendar_context_for_self()
+    if _ctx is not None:
+        result["calendar_context"] = _ctx
     return result
 
 
+def _calendar_context_for_self() -> Optional[Dict[str, Any]]:
+    """CAL-3: lightweight calendar snapshot for the local agent. Soft-fail
+    when mig 329 isn't deployed on the project — caller drops the field."""
+    try:
+        api_key = _get_api_key()
+        if not api_key:
+            return None
+        resp = be.sb_rpc("mc_tasks_due_soon", {
+            "p_api_key": api_key,
+            "p_project_id": _PROJECT_ID,
+            "p_agent_name": AGENT_NAME,
+            "p_window_hours": 24,
+        })
+        if not (isinstance(resp, dict) and resp.get("ok")):
+            return None
+        tasks = resp.get("tasks") or []
+        from datetime import datetime as _dt_dt, timezone as _dt_tz
+        now_dt = _dt_dt.now(tz=_dt_tz.utc)
+        due_today, overdue = [], []
+        for t in tasks:
+            d = t.get("due_at")
+            if not d:
+                continue
+            try:
+                dt = _dt_dt.fromisoformat(str(d).replace("Z", "+00:00"))
+            except Exception:
+                continue
+            (overdue if dt < now_dt else due_today).append(t)
+        if not (due_today or overdue):
+            return None
+        return {
+            "pending_due_today": len(due_today),
+            "overdue": len(overdue),
+            "next_due": (due_today[0] if due_today else (overdue[0] if overdue else None)),
+        }
+    except Exception:
+        return None
+
+
 @mcp.tool()
 @with_working_status
 def meshcode_status() -> Dict[str, Any]:
@@ -3914,26 +3963,54 @@ def meshcode_init(project: str, agent: str, role: str = "") -> Dict[str, Any]:
 @mcp.tool()
 @with_working_status
 def meshcode_task_create(title: str, description: str = "", assignee: Optional[str] = None,
-                          priority: str = "normal", parent_task_id: Optional[str] = None) -> Dict[str, Any]:
+                          priority: str = "normal", parent_task_id: Optional[str] = None,
+                          due: Optional[str] = None,
+                          depends_on: Optional[List[str]] = None) -> Dict[str, Any]:
     """Create task. assignee = explicit agent name OR 'auto' for round-robin
     onto the least-loaded live agent in this meshwork. priority: low/normal/high/urgent.
 
     Per Samuel rule (mig 213): wildcard '*' / NULL / '' assignees are forbidden —
     every task must have a concrete owner or opt into 'auto' resolution.
+
+    CAL-2 (mig 329):
+      due:        natural-language deadline ("by Thursday", "in 3 days",
+                  "tomorrow", "May 25") OR ISO 8601 ("2026-05-25T15:00Z").
+                  Stored as both due_at (parsed datetime) and due_label
+                  (the original human string, for round-trip display).
+      depends_on: list of task UUIDs that must reach status=done/cancelled
+                  before this task is unblocked.
     """
     if not title or not title.strip():
         return {"error": "title cannot be empty"}
-    # Mirror the RPC validation client-side so the LLM gets a clear hint
-    # before round-tripping. Do not silently coerce — the caller must choose.
     if assignee is None or not str(assignee).strip() or str(assignee).strip() == "*":
         return {
             "error": "assignee_required",
             "hint": "specify an explicit agent name OR pass assignee='auto' for round-robin",
         }
+    # CAL-2: parse natural-language due dates client-side. The label round-trips
+    # so the dashboard can show "by Thursday" verbatim instead of an ISO blob.
+    parsed_due_at = None
+    parsed_due_label = None
+    if due:
+        try:
+            from meshcode import date_parse
+            _dt, _lbl = date_parse.parse_due(due)
+            parsed_due_label = _lbl
+            if _dt is not None:
+                parsed_due_at = _dt.isoformat()
+            else:
+                return {
+                    "error": "due_unparseable",
+                    "hint": f"could not parse {due!r}; try ISO 8601 or 'by <day>' / 'in N days' / 'tomorrow'",
+                }
+        except Exception as _de:
+            return {"error": f"due_parse_failed: {_de}"}
     api_key = _get_api_key()
     result = be.task_create(api_key, _PROJECT_ID, AGENT_NAME, title.strip(),
                            description=description, assignee=assignee,
-                           priority=priority, parent_task_id=parent_task_id)
+                           priority=priority, parent_task_id=parent_task_id,
+                           due_at=parsed_due_at, due_label=parsed_due_label,
+                           depends_on=depends_on or None)
     # Auto-notify the resolved assignee so they wake from meshcode_wait.
     # Read result["assignee"] (server may have resolved 'auto' to a real name).
     if isinstance(result, dict) and result.get("ok"):
@@ -4829,6 +4906,78 @@ def meshcode_boot() -> Dict[str, Any]:
             _PERSONA = ph
             _PERSONA_INJECTED = False  # let with_working_status surface it once
 
+    # CAL-3 calendar context (mig 329): surface upcoming due tasks +
+    # overdue count + newly-unblocked so the agent knows the cadence
+    # backlog without a second tool call. Soft-fail if mig 329 not
+    # applied on this project.
+    try:
+        _due_resp = be.sb_rpc("mc_tasks_due_soon", {
+            "p_api_key": api_key,
+            "p_project_id": _PROJECT_ID,
+            "p_agent_name": AGENT_NAME,
+            "p_window_hours": 24,
+        })
+        if isinstance(_due_resp, dict) and _due_resp.get("ok"):
+            _due_tasks = _due_resp.get("tasks") or []
+            _now_iso = _time.time()
+            _due_today = []
+            _overdue = []
+            from datetime import datetime as _dt_dt, timezone as _dt_tz
+            _now_dt = _dt_dt.now(tz=_dt_tz.utc)
+            for _t in _due_tasks:
+                _due_at_str = _t.get("due_at")
+                if not _due_at_str:
+                    continue
+                try:
+                    _due_dt = _dt_dt.fromisoformat(str(_due_at_str).replace("Z", "+00:00"))
+                except Exception:
+                    continue
+                if _due_dt < _now_dt:
+                    _overdue.append(_t)
+                else:
+                    _due_today.append(_t)
+            calendar_block = {
+                "pending_due_today": len(_due_today),
+                "overdue": len(_overdue),
+                "next_due": (_due_today[0] if _due_today else (_overdue[0] if _overdue else None)),
+                "due_tasks": _due_today + _overdue,
+            }
+            resp["calendar_context"] = calendar_block
+    except Exception:
+        resp.setdefault("calendar_context_available", False)
+
+    # UX-time-aware (mig 328 / task 4056b216): augment mesh_status rows with
+    # cadence hints so the LLM can adjust tone (less pushy on deep-silence
+    # peers, fine to ping on warm ones). Soft-fail if RPC unavailable on the
+    # current project — mc_boot already gave us mesh_status without it.
+    try:
+        tc = be.sb_rpc("mc_agent_time_context_all", {
+            "p_api_key": api_key,
+            "p_project_id": _PROJECT_ID,
+        })
+        if isinstance(tc, dict) and tc.get("ok") and isinstance(tc.get("agents"), list):
+            ctx_by_name: Dict[str, Dict[str, Any]] = {}
+            for entry in tc["agents"]:
+                # The bulk RPC wraps each context in a single-item list per row;
+                # be lenient about both shapes.
+                if isinstance(entry, list) and entry:
+                    entry = entry[0]
+                if isinstance(entry, dict) and entry.get("agent"):
+                    ctx_by_name[entry["agent"]] = entry
+            mesh = resp.get("mesh_status") or []
+            if isinstance(mesh, list):
+                for row in mesh:
+                    n = row.get("name") if isinstance(row, dict) else None
+                    if n and n in ctx_by_name:
+                        c = ctx_by_name[n]
+                        row["idle_bucket"] = c.get("idle_bucket")
+                        row["idle_seconds"] = c.get("idle_seconds")
+                        row["cadence_hint"] = c.get("cadence_hint")
+            resp.setdefault("time_context_available", True)
+    except Exception:
+        # Non-fatal: surface that the hints are unavailable but boot succeeds.
+        resp.setdefault("time_context_available", False)
+
     return resp
 
 

{meshcode-2.11.12 → meshcode-2.11.14}/meshcode.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: meshcode
-Version: 2.11.12
+Version: 2.11.14
 Summary: Real-time communication between AI agents — Supabase-backed CLI
 Author-email: MeshCode <hello@meshcode.io>
 License: MIT

{meshcode-2.11.12 → meshcode-2.11.14}/meshcode.egg-info/SOURCES.txt

@@ -8,6 +8,7 @@ meshcode/cli.py
 meshcode/comms_v4.py
 meshcode/compat.py
 meshcode/daemon.py
+meshcode/date_parse.py
 meshcode/doctor.py
 meshcode/error_hints.py
 meshcode/exceptions.py
@@ -199,6 +200,7 @@ tests/test_boot_bug_regression.py
 tests/test_color_truecolor.py
 tests/test_core.py
 tests/test_cross_agent_messaging.py
+tests/test_date_parse.py
 tests/test_doctor.py
 tests/test_epistemic_v1_python_sdk.py
 tests/test_epistemic_v1_stop_conditions.py

{meshcode-2.11.12 → meshcode-2.11.14}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "meshcode"
-version = "2.11.12"
+version = "2.11.14"
 description = "Real-time communication between AI agents — Supabase-backed CLI"
 readme = "README.md"
 license = {text = "MIT"}

meshcode-2.11.14/tests/test_date_parse.py

@@ -0,0 +1,112 @@
+"""Tests for meshcode/date_parse.py."""
+from datetime import datetime, timedelta, timezone
+
+import pytest
+
+from meshcode.date_parse import parse_due
+
+
+@pytest.fixture
+def now():
+    # Pin "now" to a Wednesday 2026-05-20 12:00 UTC for deterministic tests.
+    return datetime(2026, 5, 20, 12, 0, tzinfo=timezone.utc)
+
+
+def test_empty_returns_none(now):
+    assert parse_due("", now) == (None, "")
+
+
+def test_unknown_returns_none(now):
+    dt, label = parse_due("yesterday-ish", now)
+    assert dt is None
+    assert label == "yesterday-ish"
+
+
+def test_iso_passthrough_utc(now):
+    dt, label = parse_due("2026-05-25T15:00:00Z", now)
+    assert dt == datetime(2026, 5, 25, 15, 0, tzinfo=timezone.utc)
+    assert label == "2026-05-25T15:00:00Z"
+
+
+def test_iso_date_only(now):
+    dt, label = parse_due("2026-05-25", now)
+    assert dt.year == 2026 and dt.month == 5 and dt.day == 25
+
+
+def test_today_returns_eod(now):
+    dt, _ = parse_due("today", now)
+    assert dt.date() == now.date()
+    assert dt.hour == 23 and dt.minute == 59
+
+
+def test_tomorrow(now):
+    dt, _ = parse_due("tomorrow", now)
+    assert dt.date() == (now + timedelta(days=1)).date()
+
+
+def test_in_3_days(now):
+    dt, _ = parse_due("in 3 days", now)
+    assert (dt.date() - now.date()).days == 3
+
+
+def test_in_2_hours(now):
+    dt, _ = parse_due("in 2 hours", now)
+    delta = dt - now
+    assert 1.9 * 3600 <= delta.total_seconds() <= 2.1 * 3600
+
+
+def test_in_1_week(now):
+    dt, _ = parse_due("in 1 week", now)
+    assert (dt.date() - now.date()).days == 7
+
+
+def test_weekday_alone_returns_next_match(now):
+    """Wed → 'thursday' is tomorrow."""
+    dt, _ = parse_due("thursday", now)
+    assert dt.weekday() == 3
+    assert (dt.date() - now.date()).days == 1
+
+
+def test_by_weekday(now):
+    dt, _ = parse_due("by friday", now)
+    assert dt.weekday() == 4
+
+
+def test_next_weekday(now):
+    """'next thursday' said on Wed → not tomorrow, but the one a week later."""
+    dt, _ = parse_due("next thursday", now)
+    assert dt.weekday() == 3
+    assert (dt.date() - now.date()).days >= 7
+
+
+def test_same_day_weekday_means_next_week(now):
+    """Wed → 'wednesday' is NOT today (convention)."""
+    dt, _ = parse_due("wednesday", now)
+    assert dt.weekday() == 2
+    assert (dt.date() - now.date()).days == 7
+
+
+def test_month_day_current_year(now):
+    dt, _ = parse_due("May 25", now)
+    assert dt.year == 2026 and dt.month == 5 and dt.day == 25
+
+
+def test_month_day_past_rolls_to_next_year(now):
+    """May 1 already passed in pinned now=May 20 → roll to next year."""
+    dt, _ = parse_due("May 1", now)
+    assert dt.year == 2027 and dt.month == 5 and dt.day == 1
+
+
+def test_day_month_reverse(now):
+    dt, _ = parse_due("25 May", now)
+    assert dt.year == 2026 and dt.month == 5 and dt.day == 25
+
+
+def test_explicit_year_month_day(now):
+    dt, _ = parse_due("May 25, 2030", now)
+    assert dt.year == 2030
+
+
+def test_label_preserves_original(now):
+    _, label = parse_due("by Thursday", now)
+    assert label == "by Thursday"