taskflow-agent 0.6.0__tar.gz → 0.6.2__tar.gz

taskflow_agent-0.6.2/.gitignore

@@ -0,0 +1,22 @@
+venv/
+__pycache__/
+*.pyc
+*.db
+.claude/
+.excel_mcp_server.pid
+exports/
+logs/
+.env
+data/taskflow-web.pid
+data/agent_memory.md
+data/repos.json
+data/repos.json.lock
+# data/workflows/ — now tracked in git
+data/ideas/
+.gstack/
+.DS_Store
+.context/
+dist/
+*.db-wal
+*.db-shm
+data/contexts/

{taskflow_agent-0.6.0 → taskflow_agent-0.6.2}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.4
+Metadata-Version: 2.5
 Name: taskflow-agent
-Version: 0.6.0
+Version: 0.6.2
 Summary: Lightweight project and task manager with MCP tools for Claude Code
 Project-URL: Repository, https://github.com/henrysouchien/taskflow-agent
 Author: Henry Chien
@@ -16,7 +16,7 @@ Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Topic :: Office/Business :: Scheduling
 Requires-Python: >=3.10
-Requires-Dist: mcp>=1.0.0
+Requires-Dist: mcp<2,>=1.30.0
 Provides-Extra: web
 Requires-Dist: fastapi; extra == 'web'
 Requires-Dist: python-dotenv; extra == 'web'

{taskflow_agent-0.6.0 → taskflow_agent-0.6.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "taskflow-agent"
-version = "0.6.0"
+version = "0.6.2"
 description = "Lightweight project and task manager with MCP tools for Claude Code"
 readme = "README.md"
 requires-python = ">=3.10"
@@ -24,7 +24,7 @@ classifiers = [
     "Topic :: Office/Business :: Scheduling",
 ]
 dependencies = [
-    "mcp>=1.0.0",
+    "mcp>=1.30.0,<2",
 ]
 
 [project.optional-dependencies]

taskflow_agent-0.6.2/src/approval_policy.py

@@ -0,0 +1,42 @@
+from __future__ import annotations
+
+from collections.abc import Callable, Collection, Mapping
+from typing import Any
+
+
+def make_needs_approval(
+    *,
+    local_tool_names: Collection[str],
+    mutating_tool_names: Collection[str],
+    is_mcp_tool: Callable[[str], bool],
+):
+    """Build Taskflow's fail-closed tool approval boundary.
+
+    Declared local reads run without prompts. Declared local mutations and all
+    dynamically loaded MCP tools require approval. Anything not declared by
+    either boundary also requires approval so newly added tools cannot silently
+    inherit write authority.
+    """
+    local_names = frozenset(local_tool_names)
+    mutating_names = frozenset(mutating_tool_names)
+
+    def needs_approval(
+        tool_name: str,
+        tool_input: Mapping[str, Any] | None = None,
+        qualifier: str = "",
+    ) -> bool:
+        del tool_input, qualifier
+        name = str(tool_name or "").strip()
+        if name in local_names:
+            return name in mutating_names
+        try:
+            if is_mcp_tool(name):
+                return True
+        except Exception:
+            return True
+        return True
+
+    return needs_approval
+
+
+__all__ = ["make_needs_approval"]

taskflow_agent-0.6.2/src/calendar_context.py

@@ -0,0 +1,39 @@
+"""Authoritative calendar context for Taskflow agent prompts."""
+
+from __future__ import annotations
+
+from datetime import datetime, timezone
+import os
+from zoneinfo import ZoneInfo, ZoneInfoNotFoundError
+
+
+def current_date_context(
+    *,
+    now: datetime | None = None,
+    timezone_name: str | None = None,
+) -> str:
+    """Return timezone-aware date guidance for relative-date reasoning."""
+
+    configured_name = str(
+        timezone_name or os.getenv("TASKFLOW_TIMEZONE", "America/New_York")
+    ).strip()
+    if not configured_name:
+        configured_name = "America/New_York"
+    try:
+        local_timezone = ZoneInfo(configured_name)
+    except ZoneInfoNotFoundError as exc:
+        raise RuntimeError(f"invalid TASKFLOW_TIMEZONE: {configured_name!r}") from exc
+    instant = now or datetime.now(timezone.utc)
+    if instant.tzinfo is None:
+        instant = instant.replace(tzinfo=timezone.utc)
+    local_now = instant.astimezone(local_timezone)
+    return (
+        "CURRENT DATE CONTEXT:\n"
+        f"Today is {local_now.strftime('%A, %B')} {local_now.day}, {local_now.year} "
+        f"({local_now.date().isoformat()}).\n"
+        f"Time zone: {configured_name}. Use this date and time zone for relative dates, "
+        "deadlines, day-of-week calculations, and phrases such as today, tomorrow, or this week."
+    )
+
+
+__all__ = ["current_date_context"]

taskflow_agent-0.6.2/src/contexts.py

@@ -0,0 +1,279 @@
+"""Per-project resource discovery context helpers."""
+
+from __future__ import annotations
+
+import json
+import re
+import tempfile
+from datetime import datetime
+from pathlib import Path
+from typing import Any
+
+from . import db
+
+CONTEXTS_DIR = Path(__file__).resolve().parent.parent / "data" / "contexts"
+MAX_BYTES = 8_192
+MAX_ALIASES = 20
+MAX_SEARCH_TERMS = 30
+MAX_LOCATION_ITEMS = 10
+MAX_REPOS = 10
+MAX_ALIAS_CHARS = 100
+MAX_SEARCH_TERM_CHARS = 100
+MAX_LOCATION_CHARS = 200
+MAX_NOTES_CHARS = 500
+MAX_REPO_NAME_CHARS = 60
+_REPO_NAME_RE = re.compile(r"^[A-Za-z0-9_-]+$")
+_TOP_LEVEL_KEYS = {"aliases", "search_terms", "locations", "repos", "last_scan_at", "notes"}
+_LOCATION_KEYS = {"gdrive_folders", "roam_tags", "notes_queries", "onedrive_folders", "local_paths"}
+
+
+def get_context(project_id: int) -> dict[str, Any] | None:
+    """Return stored context with injected read-only project metadata."""
+    project_id = _normalize_project_id(project_id)
+    path = CONTEXTS_DIR / f"{project_id}.json"
+    try:
+        if path.stat().st_size > MAX_BYTES:
+            raise ValueError(f"Context for project {project_id} exceeds size limit")
+    except FileNotFoundError:
+        return None
+
+    try:
+        raw = json.loads(path.read_text(encoding="utf-8"))
+    except json.JSONDecodeError as exc:
+        raise ValueError(f"Context for project {project_id} is not valid JSON") from exc
+    if not isinstance(raw, dict):
+        raise ValueError(f"Context for project {project_id} must be a JSON object")
+
+    errors = validate_context(raw)
+    if errors:
+        raise ValueError("; ".join(errors))
+
+    stored = _normalize_context_data(raw)
+    project_name = _project_name(project_id)
+    stored["_project_id"] = project_id
+    stored["_project_name"] = project_name
+    return stored
+
+
+def save_context(project_id: int, data: dict[str, Any]) -> dict[str, Any]:
+    """Replace a project's stored context atomically after validation."""
+    project_id = _normalize_project_id(project_id)
+    if not isinstance(data, dict):
+        raise ValueError("context must be an object")
+
+    conn = db.get_conn()
+    try:
+        project = db.get_project(conn, project_id)
+    finally:
+        conn.close()
+    if not project:
+        raise ValueError(f"Project {project_id} not found")
+    if project.get("archived"):
+        raise ValueError(f"Project {project_id} is archived")
+
+    errors = validate_context(data)
+    if errors:
+        raise ValueError("; ".join(errors))
+    stored = _normalize_context_data(data)
+
+    encoded = json.dumps(stored, indent=2, sort_keys=True, ensure_ascii=True) + "\n"
+    if len(encoded.encode("utf-8")) > MAX_BYTES:
+        raise ValueError("Context exceeds size limit (8 KB)")
+
+    CONTEXTS_DIR.mkdir(parents=True, exist_ok=True)
+    path = CONTEXTS_DIR / f"{project_id}.json"
+    tmp_path: Path | None = None
+    try:
+        with tempfile.NamedTemporaryFile(
+            "w",
+            encoding="utf-8",
+            dir=CONTEXTS_DIR,
+            prefix=f".{project_id}-",
+            suffix=".tmp",
+            delete=False,
+        ) as tmp_file:
+            tmp_file.write(encoded)
+            tmp_path = Path(tmp_file.name)
+        tmp_path.replace(path)
+    except OSError:
+        if tmp_path is not None:
+            tmp_path.unlink(missing_ok=True)
+        raise
+
+    return {"status": "ok", "project_id": project_id, "path": str(path), "bytes": len(encoded.encode("utf-8"))}
+
+
+def validate_context(data: dict[str, Any]) -> list[str]:
+    """Return validation errors for stored context data."""
+    if not isinstance(data, dict):
+        return ["context must be an object"]
+
+    cleaned = _strip_readonly_fields(data)
+    errors: list[str] = []
+    unknown_keys = sorted(set(cleaned) - _TOP_LEVEL_KEYS)
+    if unknown_keys:
+        errors.append(f"Unknown context keys: {', '.join(unknown_keys)}")
+
+    errors.extend(_validate_string_list(cleaned.get("aliases", []), "aliases", MAX_ALIASES, MAX_ALIAS_CHARS))
+    errors.extend(
+        _validate_string_list(
+            cleaned.get("search_terms", []),
+            "search_terms",
+            MAX_SEARCH_TERMS,
+            MAX_SEARCH_TERM_CHARS,
+        )
+    )
+    errors.extend(_validate_locations(cleaned.get("locations", {})))
+    errors.extend(_validate_repos(cleaned.get("repos", [])))
+
+    last_scan_at = cleaned.get("last_scan_at", "")
+    if not isinstance(last_scan_at, str):
+        errors.append("last_scan_at must be a string")
+    elif last_scan_at.strip():
+        try:
+            datetime.fromisoformat(last_scan_at.strip().replace("Z", "+00:00"))
+        except ValueError:
+            errors.append("last_scan_at must be an ISO 8601 datetime string")
+
+    notes = cleaned.get("notes", "")
+    if not isinstance(notes, str):
+        errors.append("notes must be a string")
+    elif len(notes.strip()) > MAX_NOTES_CHARS:
+        errors.append(f"notes must be at most {MAX_NOTES_CHARS} characters")
+
+    return errors
+
+
+def list_contexts() -> list[dict[str, Any]]:
+    """Return summaries for valid context files and remove orphans."""
+    if not CONTEXTS_DIR.is_dir():
+        return []
+
+    conn = db.get_conn()
+    try:
+        items: list[dict[str, Any]] = []
+        for path in sorted(CONTEXTS_DIR.glob("*.json")):
+            try:
+                project_id = int(path.stem)
+            except ValueError:
+                continue
+            project = db.get_project(conn, project_id)
+            if not project:
+                path.unlink(missing_ok=True)
+                continue
+            try:
+                if path.stat().st_size > MAX_BYTES:
+                    continue
+                raw = json.loads(path.read_text(encoding="utf-8"))
+            except (OSError, ValueError, json.JSONDecodeError):
+                continue
+            if not isinstance(raw, dict):
+                continue
+            items.append(
+                {
+                    "project_id": project_id,
+                    "project_name": str(project.get("name", "")),
+                    "alias_count": len(raw.get("aliases", [])) if isinstance(raw.get("aliases"), list) else 0,
+                    "search_term_count": len(raw.get("search_terms", [])) if isinstance(raw.get("search_terms"), list) else 0,
+                    "repo_count": len(raw.get("repos", [])) if isinstance(raw.get("repos"), list) else 0,
+                    "last_scan_at": str(raw.get("last_scan_at", "")),
+                }
+            )
+        return items
+    finally:
+        conn.close()
+
+
+def delete_context(project_id: int) -> bool:
+    """Delete a project's context file if present."""
+    project_id = _normalize_project_id(project_id)
+    path = CONTEXTS_DIR / f"{project_id}.json"
+    existed = path.exists()
+    path.unlink(missing_ok=True)
+    return existed
+
+
+def _strip_readonly_fields(data: dict[str, Any]) -> dict[str, Any]:
+    return {str(key): value for key, value in data.items() if not str(key).startswith("_")}
+
+
+def _normalize_context_data(data: dict[str, Any]) -> dict[str, Any]:
+    cleaned = _strip_readonly_fields(data)
+    locations = cleaned.get("locations", {})
+    normalized_locations = {
+        key: [str(item).strip() for item in locations.get(key, []) if str(item).strip()]
+        for key in sorted(_LOCATION_KEYS)
+        if isinstance(locations, dict) and key in locations
+    }
+    return {
+        "aliases": [str(item).strip() for item in cleaned.get("aliases", []) if str(item).strip()],
+        "search_terms": [str(item).strip() for item in cleaned.get("search_terms", []) if str(item).strip()],
+        "locations": normalized_locations,
+        "repos": [str(item).strip() for item in cleaned.get("repos", []) if str(item).strip()],
+        "last_scan_at": str(cleaned.get("last_scan_at", "")).strip(),
+        "notes": str(cleaned.get("notes", "")).strip(),
+    }
+
+
+def _validate_string_list(value: Any, field: str, max_items: int, max_chars: int) -> list[str]:
+    if value is None:
+        return []
+    if not isinstance(value, list):
+        return [f"{field} must be a list"]
+    errors: list[str] = []
+    if len(value) > max_items:
+        errors.append(f"{field} must have at most {max_items} items")
+    for index, item in enumerate(value, start=1):
+        if not isinstance(item, str):
+            errors.append(f"{field}[{index}] must be a string")
+            continue
+        if len(item.strip()) > max_chars:
+            errors.append(f"{field}[{index}] must be at most {max_chars} characters")
+    return errors
+
+
+def _validate_locations(value: Any) -> list[str]:
+    if value is None:
+        return []
+    if not isinstance(value, dict):
+        return ["locations must be an object"]
+    errors: list[str] = []
+    unknown_keys = sorted(set(value) - _LOCATION_KEYS)
+    if unknown_keys:
+        errors.append(f"Unknown location keys: {', '.join(unknown_keys)}")
+    for key in sorted(_LOCATION_KEYS):
+        errors.extend(_validate_string_list(value.get(key, []), f"locations.{key}", MAX_LOCATION_ITEMS, MAX_LOCATION_CHARS))
+    return errors
+
+
+def _validate_repos(value: Any) -> list[str]:
+    if value is None:
+        return []
+    errors = _validate_string_list(value, "repos", MAX_REPOS, MAX_REPO_NAME_CHARS)
+    if not isinstance(value, list):
+        return errors
+    for index, item in enumerate(value, start=1):
+        if isinstance(item, str) and item.strip() and not _REPO_NAME_RE.match(item.strip()):
+            errors.append(f"repos[{index}] has invalid repo name")
+    return errors
+
+
+def _normalize_project_id(project_id: int) -> int:
+    if isinstance(project_id, bool):
+        raise ValueError("project_id must be an integer")
+    try:
+        value = int(project_id)
+    except (TypeError, ValueError) as exc:
+        raise ValueError("project_id must be an integer") from exc
+    if value <= 0:
+        raise ValueError("project_id must be a positive integer")
+    return value
+
+
+def _project_name(project_id: int) -> str:
+    conn = db.get_conn()
+    try:
+        project = db.get_project(conn, project_id)
+    finally:
+        conn.close()
+    return str(project.get("name", "")) if project else ""