mcp-tasker 1.0.0__py3-none-any.whl

mcp_tasker-1.0.0.dist-info/METADATA

@@ -0,0 +1,259 @@
+Metadata-Version: 2.4
+Name: mcp-tasker
+Version: 1.0.0
+Summary: Simple file-based task tracker for git repos
+License: MIT License
+         
+         Copyright (c) [2026] [Evgeniy A. Cymbalyuk <cimbaluk@gmail.com>]
+         
+         Permission is hereby granted, free of charge, to any person obtaining a copy
+         of this software and associated documentation files (the "Software"), to deal
+         in the Software without restriction, including without limitation the rights
+         to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+         copies of the Software, and to permit persons to whom the Software is
+         furnished to do so, subject to the following conditions:
+         
+         The above copyright notice and this permission notice shall be included in all
+         copies or substantial portions of the Software.
+         
+         THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+         IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+         FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+         AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+         LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+         OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+         SOFTWARE.
+License-File: LICENSE
+Author: Evgeniy A. Cymbalyuk
+Author-email: cimbaluk@gmail.com
+Requires-Python: >=3.10
+Classifier: License :: Other/Proprietary License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Requires-Dist: jinja2 (>=3.1.6,<4.0.0)
+Requires-Dist: mcp (>=1.26.0,<2.0.0)
+Requires-Dist: pydantic (>=2.0)
+Requires-Dist: typer (>=0.12.0)
+Requires-Dist: typer-di (>=0.1.0)
+Project-URL: Repository, https://github.com/greendwin/mcp-tasker
+Description-Content-Type: text/markdown
+
+# Tasker
+
+[![tests](https://github.com/greendwin/mcp-tasker/actions/workflows/ci.yml/badge.svg)](https://github.com/greendwin/mcp-tasker/actions/workflows/ci.yml)
+
+A simple file-based task tracker for git repositories. Tasks are stored as plain Markdown files inside a `tasker/` directory, tracked alongside your code with git.
+
+## Installation
+
+Install with [pipx](https://pipx.pypa.io/) (recommended — installs in an isolated environment):
+
+```bash
+pipx install mcp-tasker
+```
+
+Or with pip:
+
+```bash
+pip install mcp-tasker
+```
+
+For development (requires [Poetry](https://python-poetry.org/)):
+
+```bash
+git clone https://github.com/greendwin/mcp-tasker.git
+cd mcp-tasker
+poetry install --with dev
+```
+
+## Quick Start
+
+```bash
+# Create a story
+tasker new "Build authentication"
+
+# Add subtasks
+tasker add s01 "Design login flow"
+tasker add s01 "Implement JWT tokens" --details "Use RS256 signing"
+
+# Work on a task
+tasker start s01t01
+
+# View what's on your plate
+tasker list
+
+# Mark tasks done
+tasker done s01t01
+
+# Edit a task in your editor
+tasker edit s01t02
+```
+
+Tasks are stored as Markdown in `tasker/` and committed with your code:
+
+```
+tasker/
+  s01-build-authentication/
+    README.md
+    s01t01-design-login-flow.md
+    s01t02-implement-jwt-tokens.md
+```
+
+## Usage
+
+### Create tasks
+
+```bash
+tasker new <title>                          # new root story
+tasker new <title> --details "..." --slug <slug>  # with description and slug
+tasker add <parent-id> <title>              # inline subtask
+tasker add <parent-id> <title> --details "..."    # subtask with description
+tasker add-many <parent-id>                 # add multiple subtasks interactively
+```
+
+### Update status
+
+```bash
+tasker start <task-id>...     # mark in-progress
+tasker done <task-id>...      # mark done
+tasker cancel <task-id>...    # cancel
+tasker reset <task-id>...     # reset to pending
+
+# Force-close a parent with open subtasks
+tasker done <task-id> --force
+```
+
+### View tasks
+
+```bash
+tasker list                   # all open root tasks
+tasker list -a                # include closed tasks
+tasker list <task-id>         # subtasks of a specific task
+tasker view <task-id>         # full task details
+```
+
+### Edit tasks
+
+```bash
+tasker edit <task-id>                    # open in $EDITOR
+tasker edit <task-id> --title "New title"
+tasker edit <task-id> --details "New description"
+tasker edit <task-id> --slug new-slug
+```
+
+### Organize
+
+```bash
+tasker move <task-id> --parent <new-parent>  # reparent
+tasker move <task-id> --root                 # promote to story
+tasker archive <task-id>                     # archive completed story
+tasker archive --closed                      # archive all closed stories
+tasker unarchive <task-id>                   # restore from archive
+```
+
+### Shortcuts
+
+Reference recent tasks without typing full IDs:
+
+| Shortcut | Meaning |
+|---|---|
+| `q` | Last referenced task |
+| `q01` | Subtask 01 of recent |
+| `p` | Parent of recent |
+| `p03` | Sibling 03 via parent |
+
+```bash
+tasker view s01t02   # sets recent = s01t02
+tasker start q       # starts s01t02
+tasker view p        # views s01 (parent)
+tasker done q01      # marks s01t0201 done
+```
+
+## MCP Server
+
+`tasker` can run as a [Model Context Protocol](https://modelcontextprotocol.io/) server, allowing AI agents to manage your tasks directly.
+
+### Configure in Claude Code
+
+```bash
+claude mcp add tasker -- tasker mcp
+```
+
+### Configure per-project (`.mcp.json`)
+
+```json
+{
+  "mcpServers": {
+    "tasker": {
+      "command": "tasker",
+      "args": ["mcp"]
+    }
+  }
+}
+```
+
+If running from a Poetry project:
+
+```json
+{
+  "mcpServers": {
+    "tasker": {
+      "command": "poetry",
+      "args": ["run", "tasker", "mcp"]
+    }
+  }
+}
+```
+
+### HTTP transport
+
+For network-accessible clients, start with `--port`:
+
+```bash
+tasker mcp --port 8080
+```
+
+### Available tools
+
+Once connected, the MCP server exposes:
+
+| Tool | Description |
+|---|---|
+| `create_task` | Create a root task or subtask |
+| `list_tasks` | List all root tasks |
+| `view_task` | View task details and subtasks |
+| `start_task` | Mark task in-progress |
+| `reset_task` | Reset task to pending |
+| `finish_task` | Mark task done |
+
+## Development
+
+```bash
+poetry install --with dev
+
+# Run all checks (lint + tests)
+poetry run tox
+
+# Run tests only
+poetry run tox -e test
+
+# Lint (black, isort, flake8, mypy)
+poetry run tox -e lint
+
+# Format code
+black src tests
+isort src tests
+```
+
+## Requirements
+
+- Python >= 3.10
+
+## Release Notes
+
+### 1.0.0
+- `pip` release

mcp_tasker-1.0.0.dist-info/RECORD

@@ -0,0 +1,32 @@
+tasker/__init__.py,sha256=XO80-qROIXr9L0MbIk7lqORPy6rwj4EwXCSBPXhGZi0,79
+tasker/base_types.py,sha256=kUMGLxvthFDCoccUzDeJLZ7ShcjyIWGpgml2YZwFLxs,1444
+tasker/cli/__init__.py,sha256=lqVQHcRMQC2TLyNQV7xiO2iJXUim7I5JmduH3lRyPJ0,359
+tasker/cli/_common.py,sha256=TCDLiOkMah0rBd6HWKNWS_8MMq79TndLLJKUyd87FDU,3944
+tasker/cli/_create_commands.py,sha256=Jh1fXMIL4psu_4qytQ3_coO4S5jTT4JPSew7pWWOYOo,3464
+tasker/cli/_mcp_commands.py,sha256=5rPWU6XMiqGnLBi-L-n1O6MhFtEI5ZAO1ejE7a5fNLM,533
+tasker/cli/_organize_commands.py,sha256=7pxn-jznlCbM-Pl49k5SeePJFa1Wldt5pqi1iKy8wfE,6548
+tasker/cli/_task_commands.py,sha256=rqVjT0_eLk_Js6PrqECiUxbzLp8hk-ZHd3eDDyh1rmw,10934
+tasker/cli/_view_commands.py,sha256=eApAsZUcT63BljgRHHwVPl_uKvXSKY33PgeNAxl6RKg,5106
+tasker/exceptions.py,sha256=H87OqIOafi2OdL4L5ZIaQjLmBqNkEjeUzV5YVY5jNLI,1244
+tasker/main.py,sha256=bUzAjKetL-S1mQGN61GLBtiVXez9ubn795k8HKtaFm8,65
+tasker/mcp/__init__.py,sha256=6JzQ4v85zmCUM3-jXR_HdIGorUewerg-qAV27isgO7c,476
+tasker/mcp/_common.py,sha256=VIdoF-uyuERrqo3dBHT3LJcB6yw6lYM8Dze4uI_cQcw,320
+tasker/mcp/_create_methods.py,sha256=XylMFG2VJXJnIP3xLGrRYWSzPwtWUXAw5g3EbLeXGoQ,642
+tasker/mcp/_model.py,sha256=NiTcR2gskzlKRzSZEX-38hwpkUB3zkp_L-Dky7GTfBU,1028
+tasker/mcp/_status_methods.py,sha256=lbkqdbTEdvC5_eVWGZCkoawOCyzIjtDNkBEd4hvGIhY,864
+tasker/mcp/_view_methods.py,sha256=ruxAHLWhJezECklvdmtsRrFUnt2jzhWPXdLvsoJAgIY,1252
+tasker/parse.py,sha256=BDZRnNCLACUQ67zPZvq1pHYBMZhS0TgwKLaXoOAPpUg,9751
+tasker/render.py,sha256=CYUYcXrN3YvgYCg-MQxYRQ7yqer8n-3Zu44SdigsPLI,1070
+tasker/repo/__init__.py,sha256=A6jbPGNCLmrHPhWh0KmRDpl7ERt2AvWLaVpX9oTz_eU,117
+tasker/repo/_archive_task.py,sha256=Yd_ckktf2qThP5p3lOcau81FzuDMqKJgETM7qG5y8o4,2237
+tasker/repo/_move_task.py,sha256=X3GuyQSjZihPmB25MxpArWS0_B3SOLWH3YWG0q4aqP4,3687
+tasker/repo/_task_loader.py,sha256=pedrWaPW4XMnktH0doZzPLfgKbDpDK8KhlfTbN5MfjI,8782
+tasker/repo/_task_repo.py,sha256=n01rICR81knOA0ykdZKGxWEUN23u4RePb_pyoBeKk9E,6250
+tasker/repo/_utils.py,sha256=pqI3o4x3Y8z6pAU0tAH__fq2PhrDW5IT1iIpjEG6oxc,4133
+tasker/templates/task.md.j2,sha256=inVS1mZfJiZmLFzW83zLIao0BGcD3K6VczpNIS71CtI,895
+tasker/utils.py,sha256=wv0Q2nO8G8kT2kmzC4Wdy4Rz1IgcMB4r-B_kMii0VQc,2588
+mcp_tasker-1.0.0.dist-info/METADATA,sha256=SoTdhQH7rkNziBiNSXVAUf8kIO4mwKfAbj11UV3Le4g,6654
+mcp_tasker-1.0.0.dist-info/WHEEL,sha256=kJCRJT_g0adfAJzTx2GUMmS80rTJIVHRCfG0DQgLq3o,88
+mcp_tasker-1.0.0.dist-info/entry_points.txt,sha256=6HZSWaOQnqTv1GCbedl26WwDVle0AetUfnnP-7oDlgA,42
+mcp_tasker-1.0.0.dist-info/licenses/LICENSE,sha256=kvbvfQ_OYOvMw66Znic1UBqub9iMNUwMldTiokYoOYQ,1102
+mcp_tasker-1.0.0.dist-info/RECORD,,

mcp_tasker-1.0.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: poetry-core 2.3.1
+Root-Is-Purelib: true
+Tag: py3-none-any

mcp_tasker-1.0.0.dist-info/entry_points.txt

@@ -0,0 +1,3 @@
+[console_scripts]
+tasker=tasker.main:app
+

mcp_tasker-1.0.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) [2026] [Evgeniy A. Cymbalyuk <cimbaluk@gmail.com>]
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

tasker/__init__.py

@@ -0,0 +1,3 @@
+"""tasker — file-based task tracker for git repos."""
+
+__version__ = "0.1.0"

tasker/base_types.py

@@ -0,0 +1,57 @@
+from __future__ import annotations
+
+from enum import Enum
+
+from pydantic import BaseModel
+
+EXTENDED_TASK_FILENAME = "README.md"
+
+
+class TaskStatus(str, Enum):
+    PENDING = "pending"
+    IN_PROGRESS = "in-progress"
+    DONE = "done"
+    CANCELLED = "cancelled"
+
+
+class Task(BaseModel):
+    id: str  # unique id that can be used to reference a task
+    title: str  # short summary of a task
+    status: TaskStatus = TaskStatus.PENDING
+
+    # file-task fields (None/defaults for inline tasks)
+    slug: str | None = None
+    extended: bool = False
+    description: str | None = None
+    extra_sections: str | None = None
+    subtasks: list[Task] = []
+
+    @property
+    def is_inline(self) -> bool:
+        return self.slug is None
+
+    @property
+    def is_closed(self) -> bool:
+        return self.status in (TaskStatus.DONE, TaskStatus.CANCELLED)
+
+    @property
+    def ref(self) -> str:
+        if self.slug is not None:
+            return build_task_ref(self.id, self.slug)
+        return self.id
+
+
+def build_task_ref(task_id: str, slug: str) -> str:
+    return f"{task_id}-{slug}"
+
+
+def is_root_task_id(task_id: str) -> bool:
+    assert "-" not in task_id, "task id must be provided, not task ref"
+    # HACK: tasks are in form s123t4567, root tasks are always s123 without `t` suffix
+    return "t" not in task_id
+
+
+def is_nonleaf_task(task: Task) -> bool:
+    if not task.is_inline and task.subtasks:
+        return True
+    return False

tasker/cli/__init__.py

@@ -0,0 +1,8 @@
+__all__ = ["app"]
+
+from . import _create_commands as _create_commands  # noqa: F401
+from . import _mcp_commands as _mcp_commands  # noqa: F401
+from . import _organize_commands as _organize_commands  # noqa: F401
+from . import _task_commands as _task_commands  # noqa: F401
+from . import _view_commands as _view_commands  # noqa: F401
+from ._common import app

tasker/cli/_common.py

@@ -0,0 +1,138 @@
+import re
+from pathlib import Path
+from typing import Annotated
+
+import typer
+from typer_di import TyperDI
+
+from tasker.base_types import Task
+from tasker.exceptions import TaskArchivedError, TaskValidateError
+from tasker.parse import make_child_ref, parse_task_ref
+from tasker.repo import TaskRepo
+from tasker.utils import JsonAppend, console, read_text, write_text
+
+_RECENT_FILE = ".recent"
+_GITIGNORE_FILE = ".gitignore"
+
+
+app = TyperDI(
+    name="tasker",
+    help="File-based task tracker for git repos.",
+    no_args_is_help=True,
+    pretty_exceptions_show_locals=False,
+)
+
+
+@app.callback()
+def common_options(
+    debug: Annotated[
+        bool, typer.Option("--debug", help="Show full tracebacks on errors.")
+    ] = False,
+    json_output: Annotated[
+        bool, typer.Option("--json-output", help="Output result in json format.")
+    ] = False,
+) -> None:
+    console.debug = debug
+    console.json_output = json_output
+
+
+def get_task_repo() -> TaskRepo:
+    tasker_dir = Path("tasker")
+    tasker_dir.mkdir(exist_ok=True)
+    return TaskRepo(tasker_dir)
+
+
+def resolve_ref(
+    repo: TaskRepo,
+    task_ref: str,
+    *,
+    save_recent: bool = False,
+    auto_unarchive: bool = False,
+) -> Task:
+    is_direct_link = task_ref.startswith("s")
+    if not is_direct_link:
+        task_ref = _resolve_recent(repo, task_ref)
+
+    if auto_unarchive and repo.is_archived_task(task_ref):
+        ref = parse_task_ref(task_ref)
+        repo.unarchive_root_task(ref.root_id)
+        root = repo.resolve_ref(ref.root_id)
+        console.print(
+            f"[yellow]Unarchiving [blue]{root.ref}[/blue] automatically.[/yellow]",
+            json_output={"unarchived_ref": JsonAppend(ref.root_id)},
+        )
+
+    try:
+        task = repo.resolve_ref(task_ref)
+    except TaskArchivedError as ex:
+        if console.json_output:
+            raise
+
+        console.print(f"[yellow]Task [blue]{ex.task_ref}[/blue] is archived.[/yellow]")
+        console.print("Unarchive it first before performing actions on it.")
+        raise typer.Exit(1) from ex
+
+    if save_recent and is_direct_link:
+        save_recent_task(repo, task.id)
+
+    return task
+
+
+def save_recent_task(repo: TaskRepo, task_id: str) -> None:
+    _ensure_gitignore(repo.root)
+    write_text(repo.root / _RECENT_FILE, task_id + "\n")
+
+
+def _resolve_recent(repo: TaskRepo, task_ref: str) -> str:
+    if not task_ref.startswith(("p", "q")):
+        # resolve as-is, try to resolve in repo
+        return task_ref
+
+    recent_ref = _load_recent(repo, task_ref)
+
+    if task_ref == "q":
+        return recent_ref
+
+    # links like q0102
+    if m := re.fullmatch(r"q((?:\d{2})+)", task_ref):
+        return make_child_ref(recent_ref, m.group(1))
+
+    # links like p, p01, pp, pp0102
+    if m := re.fullmatch(r"(p+)((?:\d{2})+)?", task_ref):
+        ancestor_id = recent_ref
+        for _ in range(len(m.group(1))):
+            ancestor_id = parse_task_ref(ancestor_id).parent_id
+        digits = m.group(2)
+
+        if digits:
+            return make_child_ref(ancestor_id, digits)
+        return ancestor_id
+
+    raise TaskValidateError(f"Invalid recent reference {task_ref!r}", task_ref=task_ref)
+
+
+def _load_recent(repo: TaskRepo, task_ref: str) -> str:
+    path = repo.root / _RECENT_FILE
+    if not path.exists():
+        raise TaskValidateError("Recent task was not set yet", task_ref=task_ref)
+
+    text = path.read_text().strip()
+    if not text:
+        raise TaskValidateError("Recent task was not set yet", task_ref=task_ref)
+
+    return text
+
+
+def _ensure_gitignore(root: Path) -> None:
+    gitignore = root / _GITIGNORE_FILE
+    if not gitignore.exists():
+        write_text(gitignore, _GITIGNORE_FILE + "\n" + _RECENT_FILE + "\n")
+        return
+
+    content = read_text(gitignore)
+    if _RECENT_FILE in content.splitlines():
+        return
+    if not content.endswith("\n"):
+        content += "\n"
+    content += _RECENT_FILE + "\n"
+    write_text(gitignore, content)

tasker/cli/_create_commands.py

@@ -0,0 +1,103 @@
+import sys
+from typing import Annotated, Optional
+
+import typer
+from typer_di import Depends
+
+from tasker.repo import TaskRepo
+from tasker.utils import console
+
+from ._common import app, get_task_repo, resolve_ref, save_recent_task
+
+
+@app.command("new", help="Create a new top-level task.")
+def cmd_new_task(
+    *,
+    title: Annotated[str, typer.Argument(help="Task title.")],
+    details: Annotated[
+        Optional[str], typer.Option("--details", "-d", help="Task description.")
+    ] = None,
+    slug: Annotated[
+        Optional[str], typer.Option("--slug", help="Override auto-derived slug.")
+    ] = None,
+    extended: Annotated[
+        bool, typer.Option("--extended", help="Create task as a directory.")
+    ] = False,
+    repo: TaskRepo = Depends(get_task_repo),
+) -> None:
+    with console.catching_output():
+        task = repo.create_root_task(
+            title=title, description=details, slug=slug, extended=extended
+        )
+        repo.flush_to_disk()
+        save_recent_task(repo, task.id)
+
+        console.print(
+            f"[green]Task [blue]{task.ref}[/blue] created[/green]",
+            json_output={"task_ref": task.ref},
+        )
+
+
+@app.command("add", help="Add a subtask to an existing task.")
+def cmd_add_task(
+    *,
+    parent_ref: Annotated[str, typer.Argument(help="Parent task ID.")],
+    title: Annotated[str, typer.Argument(help="Subtask title.")],
+    details: Annotated[
+        Optional[str], typer.Option("--details", "-d", help="Task description.")
+    ] = None,
+    slug: Annotated[
+        Optional[str], typer.Option("--slug", help="Override auto-derived slug.")
+    ] = None,
+    repo: TaskRepo = Depends(get_task_repo),
+) -> None:
+    with console.catching_output():
+        parent = resolve_ref(repo, parent_ref, save_recent=True, auto_unarchive=True)
+        child = repo.add_subtask(parent, title=title, description=details, slug=slug)
+        repo.flush_to_disk()
+
+        console.print(
+            f"[green]Task [blue]{child.ref}[/blue]"
+            f" added to [blue]{parent.ref}[/blue][/green]",
+            json_output={"task_ref": child.ref},
+        )
+
+
+@app.command("add-many", help="Interactively add multiple subtasks.")
+def cmd_add_many_tasks(
+    *,
+    parent_ref: Annotated[str, typer.Argument(help="Parent task ID.")],
+    repo: TaskRepo = Depends(get_task_repo),
+) -> None:
+    with console.catching_output():
+        parent = resolve_ref(repo, parent_ref, save_recent=True)
+
+        console.print(
+            f"[cyan]Adding tasks to [blue]{parent.ref}[/blue][/cyan]"
+            " (empty line to finish):",
+            json_output={"parent_ref": parent_ref},
+        )
+
+        task_refs: list[str] = []
+        while True:
+            console.print("  [dim]>[/dim] ", end="")
+            line = sys.stdin.readline()
+            if not line or not line.strip():
+                break
+            child = repo.add_subtask(parent, title=line.strip())
+            repo.flush_to_disk()
+            task_refs.append(child.ref)
+            console.print(f"  [green]task [blue]{child.ref}[/blue] added[/green]")
+
+        if not task_refs:
+            console.print(
+                "[yellow]No tasks added.[/yellow]",
+                json_output={"task_refs": []},
+            )
+            return
+
+        console.print(
+            f"[green]Done:[/green] {len(task_refs)} task(s) added"
+            f" to [blue]{parent.id}[/blue]",
+            json_output={"task_refs": task_refs},
+        )

tasker/cli/_mcp_commands.py

@@ -0,0 +1,25 @@
+import asyncio
+from typing import Annotated
+
+import typer
+
+from tasker.mcp import mcp
+
+from ._common import app
+
+
+@app.command(
+    "mcp", help="Start MCP server (stdio transport, or HTTP if --port is given)."
+)
+def cmd_mcp(
+    port: Annotated[
+        int | None,
+        typer.Option("--port", help="Port to listen on (starts HTTP/SSE server)."),
+    ] = None,
+) -> None:
+    if port is None:
+        asyncio.run(mcp.run_stdio_async())
+        return
+
+    mcp.settings.port = port
+    asyncio.run(mcp.run_streamable_http_async())