taskill 0.1.1__py3-none-any.whl

taskill/git_state.py

@@ -0,0 +1,147 @@
+"""Read project state from git, filesystem, and (optionally) pyqual reports."""
+from __future__ import annotations
+
+import hashlib
+import json
+import re
+import subprocess
+from dataclasses import dataclass, field
+from pathlib import Path
+
+
+@dataclass
+class Commit:
+    sha: str
+    short_sha: str
+    author: str
+    date: str
+    subject: str
+    body: str = ""
+
+    @property
+    def conventional_type(self) -> str | None:
+        """Parse 'feat(scope): xxx' → 'feat'. Returns None if not conventional."""
+        m = re.match(r"^(feat|fix|docs|chore|refactor|test|perf|ci|build|style|revert)(\([^)]+\))?!?:\s",
+                     self.subject)
+        return m.group(1) if m else None
+
+    @property
+    def is_breaking(self) -> bool:
+        return "!" in self.subject.split(":")[0] or "BREAKING CHANGE" in self.body
+
+
+@dataclass
+class ProjectSnapshot:
+    head_sha: str | None
+    commits_since_last_run: list[Commit] = field(default_factory=list)
+    changed_files: list[str] = field(default_factory=list)
+    coverage_pct: float | None = None
+    failed_tests: int | None = None
+    sumd_hash: str | None = None
+    sumd_text: str | None = None
+    sumr_text: str | None = None
+
+
+def _run(cmd: list[str], cwd: Path) -> str:
+    try:
+        out = subprocess.run(
+            cmd, cwd=cwd, capture_output=True, text=True, check=False, timeout=30
+        )
+        return out.stdout.strip()
+    except (subprocess.TimeoutExpired, FileNotFoundError):
+        return ""
+
+
+def head_sha(project_root: Path) -> str | None:
+    sha = _run(["git", "rev-parse", "HEAD"], project_root)
+    return sha or None
+
+
+def commits_since(project_root: Path, since_sha: str | None) -> list[Commit]:
+    """Get commits since a SHA (exclusive). If since_sha is None, return last 50."""
+    rng = f"{since_sha}..HEAD" if since_sha else "-50"
+    sep = "\x1e"  # record sep
+    fmt = f"%H{sep}%h{sep}%an{sep}%aI{sep}%s{sep}%b\x1f"
+    raw = _run(["git", "log", rng, f"--pretty=format:{fmt}"], project_root)
+    if not raw:
+        return []
+    commits: list[Commit] = []
+    for record in raw.split("\x1f"):
+        record = record.strip("\n")
+        if not record:
+            continue
+        parts = record.split(sep)
+        if len(parts) < 5:
+            continue
+        sha, short, author, date, subject = parts[:5]
+        body = parts[5] if len(parts) > 5 else ""
+        commits.append(Commit(sha=sha, short_sha=short, author=author,
+                              date=date, subject=subject, body=body))
+    return commits
+
+
+def changed_files_since(project_root: Path, since_sha: str | None) -> list[str]:
+    if not since_sha:
+        return []
+    out = _run(["git", "diff", "--name-only", f"{since_sha}..HEAD"], project_root)
+    return [line for line in out.splitlines() if line]
+
+
+def read_coverage(project_root: Path) -> float | None:
+    """Look for common coverage report locations."""
+    for candidate in ("coverage.json", ".coverage.json", "htmlcov/coverage.json"):
+        p = project_root / candidate
+        if p.exists():
+            try:
+                data = json.loads(p.read_text(encoding="utf-8"))
+                pct = data.get("totals", {}).get("percent_covered")
+                if pct is not None:
+                    return float(pct)
+            except (json.JSONDecodeError, KeyError, TypeError):
+                pass
+    # coverage.xml — minimal extraction
+    xml = project_root / "coverage.xml"
+    if xml.exists():
+        m = re.search(r'line-rate="([0-9.]+)"', xml.read_text(encoding="utf-8"))
+        if m:
+            return float(m.group(1)) * 100
+    return None
+
+
+def read_failed_tests(project_root: Path) -> int | None:
+    """Look for pytest junit xml or pyqual report."""
+    for candidate in ("junit.xml", "test-results.xml", "reports/junit.xml"):
+        p = project_root / candidate
+        if p.exists():
+            xml = p.read_text(encoding="utf-8")
+            m = re.search(r'failures="(\d+)"', xml)
+            e = re.search(r'errors="(\d+)"', xml)
+            if m:
+                return int(m.group(1)) + (int(e.group(1)) if e else 0)
+    return None
+
+
+def file_hash(path: Path) -> str | None:
+    if not path.exists():
+        return None
+    return hashlib.sha256(path.read_bytes()).hexdigest()[:16]
+
+
+def collect_snapshot(
+    project_root: Path,
+    files: dict[str, str],
+    last_commit_sha: str | None,
+) -> ProjectSnapshot:
+    sumd_path = project_root / files.get("sumd", "SUMD.md")
+    sumr_path = project_root / files.get("sumr", "SUMR.md")
+
+    return ProjectSnapshot(
+        head_sha=head_sha(project_root),
+        commits_since_last_run=commits_since(project_root, last_commit_sha),
+        changed_files=changed_files_since(project_root, last_commit_sha),
+        coverage_pct=read_coverage(project_root),
+        failed_tests=read_failed_tests(project_root),
+        sumd_hash=file_hash(sumd_path),
+        sumd_text=sumd_path.read_text(encoding="utf-8") if sumd_path.exists() else None,
+        sumr_text=sumr_path.read_text(encoding="utf-8") if sumr_path.exists() else None,
+    )

taskill/providers/__init__.py

@@ -0,0 +1,37 @@
+"""Provider chain. First successful provider wins.
+
+Order is determined by config (taskill.yaml: providers: [...]).
+Default order: windsurf_mcp → openrouter → algorithmic.
+"""
+from taskill.providers.base import Provider, ProviderError, GeneratedDocs
+from taskill.providers.algorithmic import AlgorithmicProvider
+from taskill.providers.openrouter import OpenRouterProvider
+from taskill.providers.windsurf_mcp import WindsurfMcpProvider
+
+__all__ = [
+    "Provider",
+    "ProviderError",
+    "GeneratedDocs",
+    "AlgorithmicProvider",
+    "OpenRouterProvider",
+    "WindsurfMcpProvider",
+    "build_chain",
+]
+
+
+def build_chain(provider_configs):
+    """Materialize provider config list into provider instances (only enabled)."""
+    registry = {
+        "windsurf_mcp": WindsurfMcpProvider,
+        "openrouter": OpenRouterProvider,
+        "algorithmic": AlgorithmicProvider,
+    }
+    chain = []
+    for cfg in provider_configs:
+        if not cfg.enabled:
+            continue
+        cls = registry.get(cfg.name)
+        if cls is None:
+            continue
+        chain.append(cls(options=cfg.options))
+    return chain

taskill/providers/algorithmic.py

@@ -0,0 +1,155 @@
+"""Algorithmic fallback — no LLM required.
+
+Strategy:
+- Categorize commits via Conventional Commits prefixes.
+- Move TODO lines that match commit subjects (fuzzy) to changelog.
+- Detect '[x]' checkboxes in TODO and treat as completed.
+- For new TODO items: scan commits for 'TODO:' / 'FIXME:' markers in body.
+
+This is the safety net. Always available, always deterministic, ~zero deps.
+"""
+from __future__ import annotations
+
+import re
+from collections import defaultdict
+from typing import Any
+
+from taskill.providers.base import GeneratedDocs, Provider
+
+
+CATEGORY_HEADINGS = {
+    "feat":     "### Added",
+    "fix":      "### Fixed",
+    "perf":     "### Performance",
+    "refactor": "### Changed",
+    "docs":     "### Documentation",
+    "test":     "### Tests",
+    "build":    "### Build",
+    "ci":       "### CI",
+    "chore":    "### Chore",
+    "style":    "### Style",
+    "revert":   "### Reverted",
+}
+
+
+class AlgorithmicProvider(Provider):
+    name = "algorithmic"
+
+    def is_available(self) -> bool:
+        return True  # always
+
+    def generate(self, context: dict[str, Any]) -> GeneratedDocs:
+        snap = context["snapshot"]
+        existing_todo = context.get("existing_todo") or ""
+
+        # 1. group commits by conventional type
+        by_type: dict[str, list[str]] = defaultdict(list)
+        breaking: list[str] = []
+        uncategorized: list[str] = []
+        for c in snap.commits_since_last_run:
+            ctype = c.conventional_type
+            line = self._format_commit(c)
+            if c.is_breaking:
+                breaking.append(line)
+            if ctype:
+                by_type[ctype].append(line)
+            else:
+                uncategorized.append(line)
+
+        # 2. build changelog entries grouped by category
+        entries: list[str] = []
+        if breaking:
+            entries.append("### ⚠ BREAKING CHANGES")
+            entries.extend(breaking)
+        for ctype in ["feat", "fix", "perf", "refactor", "docs", "test",
+                      "build", "ci", "chore", "style", "revert"]:
+            if by_type.get(ctype):
+                entries.append(CATEGORY_HEADINGS[ctype])
+                entries.extend(by_type[ctype])
+        if uncategorized:
+            entries.append("### Other")
+            entries.extend(uncategorized)
+
+        # 3. detect completed TODOs
+        todo_completed = self._find_completed_todos(existing_todo, snap.commits_since_last_run)
+
+        # 4. extract TODO/FIXME from commit bodies
+        todo_new = self._extract_new_todos(snap.commits_since_last_run)
+
+        n_total = len(snap.commits_since_last_run)
+        summary = (
+            f"{n_total} commit(s); "
+            f"{len(by_type.get('feat', []))} features, "
+            f"{len(by_type.get('fix', []))} fixes."
+        ) if n_total else "No new commits — refreshing docs only."
+
+        return GeneratedDocs(
+            changelog_entries=entries,
+            todo_completed=todo_completed,
+            todo_new=todo_new,
+            summary=summary,
+            provider_name=self.name,
+        )
+
+    @staticmethod
+    def _format_commit(commit) -> str:  # type: ignore[no-untyped-def]
+        # strip the conventional prefix from the bullet text — heading already conveys it
+        subject = re.sub(
+            r"^(feat|fix|docs|chore|refactor|test|perf|ci|build|style|revert)(\([^)]+\))?!?:\s*",
+            "",
+            commit.subject,
+        )
+        return f"- {subject} ({commit.short_sha})"
+
+    @staticmethod
+    def _find_completed_todos(todo_text: str, commits) -> list[str]:  # type: ignore[no-untyped-def]
+        """Return TODO lines that look completed.
+
+        Two signals:
+        1. Line starts with `- [x]` or `* [x]`  → explicitly checked off.
+        2. Line content has high token overlap with a commit subject.
+        """
+        completed: list[str] = []
+        for raw_line in todo_text.splitlines():
+            line = raw_line.rstrip()
+            if not line.strip():
+                continue
+
+            # explicit checkbox
+            if re.match(r"^\s*[-*+]\s*\[[xX]\]", line):
+                completed.append(line)
+                continue
+
+            # only check unchecked todo bullets
+            m = re.match(r"^\s*[-*+]\s*(\[\s\]\s*)?(.+)$", line)
+            if not m:
+                continue
+            text = m.group(2).lower()
+            text_tokens = set(re.findall(r"\w{4,}", text))
+            if len(text_tokens) < 2:
+                continue
+            for c in commits:
+                commit_tokens = set(re.findall(r"\w{4,}", c.subject.lower()))
+                if not commit_tokens:
+                    continue
+                overlap = text_tokens & commit_tokens
+                # need ≥2 shared significant tokens AND ≥40% of TODO tokens covered.
+                # 40% (not 50%) accommodates plurals/stems without proper stemming —
+                # e.g. "refresh tokens" in TODO vs "refresh token" in commit.
+                if len(overlap) >= 2 and len(overlap) / len(text_tokens) >= 0.4:
+                    completed.append(line)
+                    break
+        return completed
+
+    @staticmethod
+    def _extract_new_todos(commits) -> list[str]:  # type: ignore[no-untyped-def]
+        new: list[str] = []
+        pat = re.compile(r"\b(TODO|FIXME|XXX)[:\s]+([^\n]+)", re.IGNORECASE)
+        seen: set[str] = set()
+        for c in commits:
+            for m in pat.finditer(c.body or ""):
+                text = m.group(2).strip().rstrip(".")[:160]
+                if text and text.lower() not in seen:
+                    seen.add(text.lower())
+                    new.append(f"- [ ] {text}")
+        return new

taskill/providers/base.py

@@ -0,0 +1,105 @@
+"""Provider abstraction + shared types."""
+from __future__ import annotations
+
+from abc import ABC, abstractmethod
+from dataclasses import dataclass
+from typing import Any
+
+
+class ProviderError(Exception):
+    """Provider failed — chain falls through to next provider."""
+
+
+@dataclass
+class GeneratedDocs:
+    """What every provider returns."""
+    readme: str | None = None
+    changelog_entries: list[str] = None  # type: ignore[assignment]  # markdown bullets
+    todo_completed: list[str] = None     # type: ignore[assignment]  # items to remove from TODO
+    todo_new: list[str] = None           # type: ignore[assignment]  # new items detected
+    summary: str = ""
+    provider_name: str = "unknown"
+
+    def __post_init__(self) -> None:
+        if self.changelog_entries is None:
+            self.changelog_entries = []
+        if self.todo_completed is None:
+            self.todo_completed = []
+        if self.todo_new is None:
+            self.todo_new = []
+
+
+class Provider(ABC):
+    """Abstract provider — produces docs from a project snapshot."""
+
+    name: str = "abstract"
+
+    def __init__(self, options: dict[str, Any] | None = None) -> None:
+        self.options = options or {}
+
+    @abstractmethod
+    def is_available(self) -> bool:
+        """Quick self-check. Should NOT raise — just return False."""
+
+    @abstractmethod
+    def generate(self, context: dict[str, Any]) -> GeneratedDocs:
+        """Generate docs.
+
+        `context` keys (see core.build_context):
+          - snapshot: ProjectSnapshot
+          - existing_readme, existing_changelog, existing_todo: str
+          - sumd, sumr: str | None
+          - project_name: str
+          - pyqual_report: dict | None
+        """
+
+
+# ─── shared prompt template (used by LLM providers) ──────────────────────
+
+SYSTEM_PROMPT = """You are taskill, a release-notes / docs janitor.
+Given a project snapshot (commits, changed files, coverage, SUMD), output STRICT JSON:
+
+{
+  "summary": "1-2 sentence high-level description of what changed",
+  "changelog_entries": ["- feat: thing one", "- fix: thing two"],
+  "todo_completed": ["- exact text of TODO line that is now done"],
+  "todo_new": ["- new thing discovered from commits"],
+  "readme_patches": null
+}
+
+Rules:
+- changelog_entries: markdown bullets, conventional-commits style if possible
+- todo_completed: copy line text VERBATIM from the existing TODO; don't paraphrase
+- Be conservative — when unsure, omit. False positives are worse than misses.
+- Output ONLY JSON. No prose. No code fences.
+"""
+
+
+def build_user_prompt(context: dict[str, Any]) -> str:
+    snap = context["snapshot"]
+    commits = "\n".join(
+        f"  {c.short_sha} {c.subject}" for c in snap.commits_since_last_run[:50]
+    ) or "  (no new commits)"
+    changed = "\n".join(f"  {f}" for f in snap.changed_files[:50]) or "  (none)"
+    todo = context.get("existing_todo") or "(empty)"
+    sumd = context.get("sumd") or "(no SUMD.md)"
+    coverage = f"{snap.coverage_pct:.1f}%" if snap.coverage_pct else "n/a"
+    failed = snap.failed_tests if snap.failed_tests is not None else "n/a"
+
+    return f"""Project: {context.get('project_name', 'unknown')}
+
+# Commits since last taskill run
+{commits}
+
+# Changed files
+{changed}
+
+# Coverage: {coverage}    Failed tests: {failed}
+
+# Current TODO.md (truncated)
+{todo[:4000]}
+
+# SUMD.md (project structure summary, truncated)
+{sumd[:3000]}
+
+Now produce the JSON described in the system prompt."""

taskill/providers/openrouter.py

@@ -0,0 +1,114 @@
+"""OpenRouter provider.
+
+Reads OPENROUTER_API_KEY and LLM_MODEL from env (loaded via .env in config).
+Uses HTTP directly to keep deps minimal — no openai SDK needed.
+"""
+from __future__ import annotations
+
+import json
+import os
+import re
+from typing import Any
+
+import httpx
+
+from taskill.providers.base import (
+    GeneratedDocs,
+    Provider,
+    ProviderError,
+    SYSTEM_PROMPT,
+    build_user_prompt,
+)
+
+
+# OpenRouter model strings often arrive as "openrouter/qwen/qwen3-coder-next" — the leading
+# "openrouter/" segment is litellm-style. The OpenRouter REST API itself wants just
+# "qwen/qwen3-coder-next". We strip the prefix automatically.
+def _normalize_model(model: str) -> str:
+    if model.startswith("openrouter/"):
+        return model[len("openrouter/"):]
+    return model
+
+
+class OpenRouterProvider(Provider):
+    name = "openrouter"
+
+    def is_available(self) -> bool:
+        return bool(os.getenv("OPENROUTER_API_KEY"))
+
+    def generate(self, context: dict[str, Any]) -> GeneratedDocs:
+        api_key = os.getenv("OPENROUTER_API_KEY")
+        if not api_key:
+            raise ProviderError("OPENROUTER_API_KEY not set")
+
+        model = _normalize_model(os.getenv("LLM_MODEL", "qwen/qwen3-coder-next"))
+        base_url = self.options.get("base_url", "https://openrouter.ai/api/v1")
+        timeout = self.options.get("timeout", 120)
+
+        payload = {
+            "model": model,
+            "temperature": self.options.get("temperature", 0.2),
+            "max_tokens": self.options.get("max_tokens", 4096),
+            "messages": [
+                {"role": "system", "content": SYSTEM_PROMPT},
+                {"role": "user", "content": build_user_prompt(context)},
+            ],
+            # JSON mode if model supports it; harmless if it doesn't
+            "response_format": {"type": "json_object"},
+        }
+
+        headers = {
+            "Authorization": f"Bearer {api_key}",
+            "Content-Type": "application/json",
+            # OpenRouter recommends these for analytics / better routing
+            "HTTP-Referer": self.options.get("referer", "https://github.com/oqlos/taskill"),
+            "X-Title": "taskill",
+        }
+
+        try:
+            with httpx.Client(timeout=timeout) as client:
+                resp = client.post(f"{base_url}/chat/completions", json=payload, headers=headers)
+        except httpx.HTTPError as e:
+            raise ProviderError(f"OpenRouter request failed: {e}") from e
+
+        if resp.status_code != 200:
+            raise ProviderError(
+                f"OpenRouter returned {resp.status_code}: {resp.text[:300]}"
+            )
+
+        try:
+            data = resp.json()
+            content = data["choices"][0]["message"]["content"]
+        except (KeyError, IndexError, json.JSONDecodeError) as e:
+            raise ProviderError(f"Malformed OpenRouter response: {e}") from e
+
+        parsed = self._parse_json_loosely(content)
+        if parsed is None:
+            raise ProviderError("Model did not return valid JSON")
+
+        return GeneratedDocs(
+            changelog_entries=list(parsed.get("changelog_entries", [])),
+            todo_completed=list(parsed.get("todo_completed", [])),
+            todo_new=list(parsed.get("todo_new", [])),
+            summary=str(parsed.get("summary", "")),
+            provider_name=f"{self.name}:{model}",
+        )
+
+    @staticmethod
+    def _parse_json_loosely(text: str) -> dict[str, Any] | None:
+        """Be forgiving: strip ```json fences, extract first {...} block."""
+        text = text.strip()
+        # strip fences
+        text = re.sub(r"^```(?:json)?\s*|\s*```$", "", text, flags=re.MULTILINE)
+        try:
+            return json.loads(text)
+        except json.JSONDecodeError:
+            pass
+        # find first balanced { ... }
+        m = re.search(r"\{.*\}", text, re.DOTALL)
+        if not m:
+            return None
+        try:
+            return json.loads(m.group(0))
+        except json.JSONDecodeError:
+            return None

taskill/providers/windsurf_mcp.py

@@ -0,0 +1,135 @@
+"""Windsurf MCP provider — first in the chain.
+
+Why first: the user runs the Windsurf plugin in JetBrains, which exposes
+an MCP server with rich workspace context (open files, diagnostics, etc.).
+If reachable, it produces better results than a cold OpenRouter call.
+
+Discovery (in order):
+  1. options.endpoint == "stdio" → spawn `windsurf mcp` (or path from options.command)
+  2. options.endpoint starts with "ws://" or "http://" → connect remotely
+  3. WINDSURF_MCP_ENDPOINT env var
+  4. Probe known JetBrains plugin sockets at ~/.codeium/windsurf/mcp.sock
+     and ~/.windsurf/mcp.sock
+
+If the optional `mcp` package is not installed, this provider is unavailable
+(returns False from is_available) and the chain falls through cleanly to
+OpenRouter. This is intentional — taskill should not require MCP to work.
+"""
+from __future__ import annotations
+
+import json
+import os
+from pathlib import Path
+from typing import Any
+
+from taskill.providers.base import (
+    GeneratedDocs,
+    Provider,
+    ProviderError,
+    SYSTEM_PROMPT,
+    build_user_prompt,
+)
+
+
+def _mcp_lib_present() -> bool:
+    try:
+        import mcp  # noqa: F401
+        return True
+    except ImportError:
+        return False
+
+
+def _candidate_endpoints(options: dict[str, Any]) -> list[str]:
+    cands: list[str] = []
+    ep = options.get("endpoint")
+    if ep:
+        cands.append(ep)
+    env_ep = os.getenv("WINDSURF_MCP_ENDPOINT")
+    if env_ep:
+        cands.append(env_ep)
+    home = Path.home()
+    for sock in (home / ".codeium" / "windsurf" / "mcp.sock",
+                 home / ".windsurf" / "mcp.sock"):
+        if sock.exists():
+            cands.append(f"unix://{sock}")
+    return cands
+
+
+class WindsurfMcpProvider(Provider):
+    name = "windsurf_mcp"
+
+    def is_available(self) -> bool:
+        if not _mcp_lib_present():
+            return False
+        # consider available if at least one candidate endpoint resolves
+        return bool(_candidate_endpoints(self.options))
+
+    def generate(self, context: dict[str, Any]) -> GeneratedDocs:
+        if not _mcp_lib_present():
+            raise ProviderError(
+                "MCP library not installed (pip install 'taskill[mcp]')"
+            )
+
+        # Lazy import — keep MCP truly optional
+        try:
+            from mcp import ClientSession  # type: ignore
+            from mcp.client.stdio import stdio_client, StdioServerParameters  # type: ignore
+        except ImportError as e:
+            raise ProviderError(f"MCP import failed: {e}") from e
+
+        endpoints = _candidate_endpoints(self.options)
+        if not endpoints:
+            raise ProviderError("No Windsurf MCP endpoint configured or discovered")
+
+        # NOTE: full MCP plumbing is async; for the working version we delegate
+        # to a sync helper that picks the simplest viable path (stdio command).
+        # Remote ws/unix transports land in the refactor (see ROADMAP.md).
+        cmd = self.options.get("command")
+        if not cmd:
+            raise ProviderError(
+                "Windsurf MCP stdio requires options.command (e.g. 'windsurf mcp serve')"
+            )
+
+        try:
+            import asyncio
+
+            async def _run() -> str:
+                params = StdioServerParameters(
+                    command=cmd[0] if isinstance(cmd, list) else cmd,
+                    args=cmd[1:] if isinstance(cmd, list) else [],
+                )
+                async with stdio_client(params) as (read, write):
+                    async with ClientSession(read, write) as session:
+                        await session.initialize()
+                        # Use a generic 'chat' or 'complete' tool exposed by the server.
+                        tool_name = self.options.get("tool_name", "complete")
+                        result = await session.call_tool(
+                            tool_name,
+                            arguments={
+                                "system": SYSTEM_PROMPT,
+                                "prompt": build_user_prompt(context),
+                            },
+                        )
+                        # MCP tool result content blocks
+                        for block in result.content:
+                            if hasattr(block, "text"):
+                                return block.text  # type: ignore[no-any-return]
+                        raise ProviderError("Empty response from MCP tool")
+
+            content = asyncio.run(_run())
+        except Exception as e:  # broad — MCP can fail many ways; surface cleanly
+            raise ProviderError(f"Windsurf MCP call failed: {e}") from e
+
+        # parse same JSON contract as OpenRouter
+        from taskill.providers.openrouter import OpenRouterProvider
+        parsed = OpenRouterProvider._parse_json_loosely(content)
+        if parsed is None:
+            raise ProviderError("Windsurf MCP did not return valid JSON")
+
+        return GeneratedDocs(
+            changelog_entries=list(parsed.get("changelog_entries", [])),
+            todo_completed=list(parsed.get("todo_completed", [])),
+            todo_new=list(parsed.get("todo_new", [])),
+            summary=str(parsed.get("summary", "")),
+            provider_name=self.name,
+        )