memtask 0.0.1__tar.gz → 0.0.2__tar.gz

memtask-0.0.2/PKG-INFO

@@ -0,0 +1,89 @@
+Metadata-Version: 2.4
+Name: memtask
+Version: 0.0.2
+Summary: A local MCP server for durable agent task state and lightweight memory.
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: mcp
+Provides-Extra: test
+Requires-Dist: pytest>=8; extra == "test"
+
+<p align="center">
+  <img src="https://raw.githubusercontent.com/PlatinumCD/memtask-mcp/master/docs/assets/memtask-logo.png" alt="MemTask logo" width="220">
+</p>
+
+<h1 align="center">MemTask</h1>
+
+MemTask gives MCP agents a local task list and lightweight memory, backed by SQLite.
+
+## Install
+
+```bash
+pip install MemTask
+```
+
+## Start
+
+```bash
+memtask start
+```
+
+MemTask starts a local MCP server at:
+
+```text
+http://127.0.0.1:8000/mcp
+```
+
+## Add It To Codex
+
+```bash
+memtask install
+```
+
+That prints the exact `codex mcp add ...` commands for stdio and HTTP:
+
+```text
+Codex
+
+stdio server
+  codex mcp add memtask -- memtask start --transport stdio
+
+HTTP server
+  memtask start
+  codex mcp add memtask --url http://127.0.0.1:8000/mcp
+```
+
+## Use It
+
+Once connected, your agent gets tools for:
+
+- tasks: add, list, focus, complete, remove, and track dependencies
+- memory: remember, recall, update, and delete scoped context
+
+## Common Commands
+
+```bash
+memtask status
+memtask stop
+memtask start --transport stdio
+```
+
+## What It Is
+
+MemTask is a local MCP server for developer-built agents that need durable task state and persistent context. It gives an agent a small workspace for tracking active work, dependency order, completed tasks, and scoped memories across sessions.
+
+State is stored locally. In this repo, MemTask uses `data/tasks.sqlite`. When installed outside this repo, it uses `~/.memtask/tasks.sqlite` by default. Set `MEMTASK_DB_PATH` to choose a specific SQLite path.
+
+## Development
+
+Run tests:
+
+```bash
+python -m pytest
+```
+
+Compile-check the package:
+
+```bash
+python -m py_compile src/memtask/*.py tests/*.py
+```

memtask-0.0.2/README.md

@@ -0,0 +1,79 @@
+<p align="center">
+  <img src="https://raw.githubusercontent.com/PlatinumCD/memtask-mcp/master/docs/assets/memtask-logo.png" alt="MemTask logo" width="220">
+</p>
+
+<h1 align="center">MemTask</h1>
+
+MemTask gives MCP agents a local task list and lightweight memory, backed by SQLite.
+
+## Install
+
+```bash
+pip install MemTask
+```
+
+## Start
+
+```bash
+memtask start
+```
+
+MemTask starts a local MCP server at:
+
+```text
+http://127.0.0.1:8000/mcp
+```
+
+## Add It To Codex
+
+```bash
+memtask install
+```
+
+That prints the exact `codex mcp add ...` commands for stdio and HTTP:
+
+```text
+Codex
+
+stdio server
+  codex mcp add memtask -- memtask start --transport stdio
+
+HTTP server
+  memtask start
+  codex mcp add memtask --url http://127.0.0.1:8000/mcp
+```
+
+## Use It
+
+Once connected, your agent gets tools for:
+
+- tasks: add, list, focus, complete, remove, and track dependencies
+- memory: remember, recall, update, and delete scoped context
+
+## Common Commands
+
+```bash
+memtask status
+memtask stop
+memtask start --transport stdio
+```
+
+## What It Is
+
+MemTask is a local MCP server for developer-built agents that need durable task state and persistent context. It gives an agent a small workspace for tracking active work, dependency order, completed tasks, and scoped memories across sessions.
+
+State is stored locally. In this repo, MemTask uses `data/tasks.sqlite`. When installed outside this repo, it uses `~/.memtask/tasks.sqlite` by default. Set `MEMTASK_DB_PATH` to choose a specific SQLite path.
+
+## Development
+
+Run tests:
+
+```bash
+python -m pytest
+```
+
+Compile-check the package:
+
+```bash
+python -m py_compile src/memtask/*.py tests/*.py
+```

{memtask-0.0.1 → memtask-0.0.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "memtask"
-version = "0.0.1"
+version = "0.0.2"
 description = "A local MCP server for durable agent task state and lightweight memory."
 readme = "README.md"
 requires-python = ">=3.10"

{memtask-0.0.1 → memtask-0.0.2}/src/memtask/__init__.py

@@ -2,4 +2,4 @@
 
 __all__ = ["__version__"]
 
-__version__ = "0.0.1"
+__version__ = "0.0.2"

{memtask-0.0.1 → memtask-0.0.2}/src/memtask/cli.py

@@ -17,6 +17,7 @@ DEFAULT_PORT = 8000
 DEFAULT_SERVER_NAME = "MemTask"
 PID_FILE = "memtask.pid"
 LOG_FILE = "memtask.log"
+COMMANDS = {"start", "stop", "status", "install", "install-help"}
 
 
 def _runtime_dir() -> Path:
@@ -70,65 +71,90 @@ def _mcp_url(host: str, port: int) -> str:
     return f"http://{host}:{port}/mcp"
 
 
-def _stdio_config_text() -> str:
-    return json.dumps(
-        {
-            "mcpServers": {
-                "memtask": {
-                    "command": "memtask",
-                    "args": ["start", "--transport", "stdio"],
-                }
-            }
-        },
-        indent=2,
-    )
+def _color(value: str, code: str, stream=None) -> str:
+    stream = sys.stdout if stream is None else stream
+    if os.environ.get("NO_COLOR") or not stream.isatty():
+        return value
+    return f"\033[{code}m{value}\033[0m"
 
 
-def _http_config_text(host: str, port: int) -> str:
-    return json.dumps(
-        {
-            "mcpServers": {
-                "memtask": {
-                    "url": _mcp_url(host, port),
-                }
-            }
-        },
-        indent=2,
-    )
+def _green(value: str) -> str:
+    return _color(value, "32")
+
+
+def _yellow(value: str) -> str:
+    return _color(value, "33")
+
+
+def _bold_white(value: str) -> str:
+    return _color(value, "1;97")
+
+
+def _bold(value: str) -> str:
+    return _color(value, "1")
+
+
+def _print_main_help() -> None:
+    print(_bold("MemTask"))
+    print("Local MCP task and memory server")
+    print()
+    print(_bold("Usage"))
+    print("  memtask start [--host 127.0.0.1] [--port 8000]")
+    print("  memtask stop")
+    print("  memtask status")
+    print("  memtask install")
+    print()
+    print(_bold("Common"))
+    print("  memtask start        Start the background HTTP server")
+    print("  memtask install      Show Codex MCP install commands")
+    print("  memtask status       Show PID, URL, log path, and DB path")
+    print()
+    print(_bold("Stdio"))
+    print("  memtask start --transport stdio")
+    print("  Use stdio only when your MCP client launches MemTask directly.")
 
 
 def _print_stdio_guidance() -> None:
-    print("MemTask starting over stdio.", file=sys.stderr)
-    print("For MCP clients that launch stdio servers, configure:", file=sys.stderr)
-    print(_stdio_config_text(), file=sys.stderr)
-    print(f"SQLite state: {get_db_path()}", file=sys.stderr)
+    print("MemTask starting over stdio; this process stays attached to the MCP client.", file=sys.stderr)
 
 
 def _print_http_guidance(host: str, port: int, pid: int | None = None) -> None:
-    print("MemTask HTTP server started.")
+    print(f"{_green('OK')} MemTask started")
     if pid is not None:
-        print(f"PID: {pid}")
-    print(f"URL: {_mcp_url(host, port)}")
-    print(f"SQLite state: {get_db_path()}")
-    print(f"Log file: {_log_path()}")
+        print(f"  PID:  {pid}")
+    print(f"  URL:  {_mcp_url(host, port)}")
+    print(f"  Data: {get_db_path()}")
+    print(f"  Logs: {_log_path()}")
     print()
-    print("For MCP clients that connect to HTTP servers, configure:")
-    print(_http_config_text(host, port))
+    print("Add it to your MCP client with:")
+    print("  memtask install")
 
 
-def _print_install_help(host: str = DEFAULT_HOST, port: int = DEFAULT_PORT) -> None:
-    print("MemTask MCP configuration examples")
-    print()
-    print("Stdio launch configuration:")
-    print(_stdio_config_text())
-    print()
-    print("HTTP mode:")
-    print(f"  memtask start --transport http --host {host} --port {port}")
+def _running_http_url(host: str = DEFAULT_HOST, port: int = DEFAULT_PORT) -> tuple[str, bool]:
+    record = _read_pid_record()
+    if record is None:
+        return _mcp_url(host, port), False
+
+    pid = int(record.get("pid", 0))
+    if not _pid_is_running(pid):
+        _clear_pid_record()
+        return _mcp_url(host, port), False
+
+    return str(record.get("url", _mcp_url(host, port))), True
+
+
+def _print_install(host: str = DEFAULT_HOST, port: int = DEFAULT_PORT) -> None:
+    url, running = _running_http_url(host=host, port=port)
+
+    print(_bold_white("Codex"))
     print()
-    print("HTTP configuration:")
-    print(_http_config_text(host, port))
+    print("stdio server")
+    print("  codex mcp add memtask -- memtask start --transport stdio")
     print()
-    print(f"Default SQLite state: {get_db_path()}")
+    print("HTTP server")
+    if not running:
+        print("  memtask start")
+    print(f"  codex mcp add memtask --url {url}")
 
 
 def _run_server(**kwargs) -> None:
@@ -152,10 +178,12 @@ def _start_http(args: argparse.Namespace) -> None:
     if record is not None:
         pid = int(record.get("pid", 0))
         if _pid_is_running(pid):
-            print("MemTask HTTP server is already running.")
-            print(f"PID: {pid}")
-            print(f"URL: {record.get('url', _mcp_url(args.host, args.port))}")
-            print(f"Stop it with: memtask stop")
+            print(f"{_yellow('RUNNING')} MemTask is already running")
+            print(f"  PID: {pid}")
+            print(f"  URL: {record.get('url', _mcp_url(args.host, args.port))}")
+            print()
+            print("Stop it with:")
+            print("  memtask stop")
             return
         _clear_pid_record()
 
@@ -214,14 +242,14 @@ def _start(args: argparse.Namespace) -> None:
 def _stop(_: argparse.Namespace) -> None:
     record = _read_pid_record()
     if record is None:
-        print("No MemTask background server is registered.")
-        print("If you are using stdio mode, your MCP client starts and stops MemTask itself.")
+        print(f"{_yellow('STOPPED')} MemTask is not running")
+        print("stdio servers are stopped by the MCP client that launched them.")
         return
 
     pid = int(record.get("pid", 0))
     if not _pid_is_running(pid):
         _clear_pid_record()
-        print("Removed stale MemTask PID file.")
+        print(f"{_yellow('STALE')} Removed old MemTask PID file.")
         return
 
     os.kill(pid, signal.SIGTERM)
@@ -232,42 +260,44 @@ def _stop(_: argparse.Namespace) -> None:
         time.sleep(0.1)
 
     _clear_pid_record()
-    print("MemTask HTTP server stopped.")
-    print("For stdio MCP clients, no stop command is needed; the client owns the server process.")
+    print(f"{_green('OK')} MemTask stopped")
+    print("stdio servers are stopped by the MCP client that launched them.")
 
 
 def _status(_: argparse.Namespace) -> None:
     record = _read_pid_record()
     if record is None:
-        print("MemTask background HTTP server is not running.")
-        print(f"SQLite state: {get_db_path()}")
-        print("For MCP client setup, run: memtask install-help")
+        print(f"{_yellow('STOPPED')} MemTask is not running")
+        print(f"  Data: {get_db_path()}")
+        print()
+        print("Start it with:")
+        print("  memtask start")
         return
 
     pid = int(record.get("pid", 0))
     if not _pid_is_running(pid):
         _clear_pid_record()
-        print("MemTask background HTTP server is not running. Removed stale PID file.")
-        print(f"SQLite state: {get_db_path()}")
+        print(f"{_yellow('STALE')} MemTask was not running; removed old PID file.")
+        print(f"  Data: {get_db_path()}")
         return
 
-    print("MemTask background HTTP server is running.")
-    print(f"PID: {pid}")
-    print(f"URL: {record.get('url')}")
-    print(f"SQLite state: {record.get('db_path', get_db_path())}")
-    print(f"Log file: {record.get('log_file', _log_path())}")
+    print(f"{_green('RUNNING')} MemTask")
+    print(f"  PID:  {pid}")
+    print(f"  URL:  {record.get('url')}")
+    print(f"  Data: {record.get('db_path', get_db_path())}")
+    print(f"  Logs: {record.get('log_file', _log_path())}")
 
 
 def build_parser() -> argparse.ArgumentParser:
-    parser = argparse.ArgumentParser(prog="memtask")
-    subcommands = parser.add_subparsers(dest="command", required=True)
+    parser = argparse.ArgumentParser(prog="memtask", add_help=False)
+    subcommands = parser.add_subparsers(dest="command")
 
     start = subcommands.add_parser("start", help="Start the MemTask MCP server")
     start.add_argument(
         "--transport",
         choices=("stdio", "http", "streamable-http"),
-        default="stdio",
-        help="Use stdio in the foreground or HTTP as a background server.",
+        default="http",
+        help="Use HTTP as a background server, or stdio when launched by an MCP client.",
     )
     start.add_argument("--host", default=DEFAULT_HOST)
     start.add_argument("--port", type=int, default=DEFAULT_PORT)
@@ -280,20 +310,30 @@ def build_parser() -> argparse.ArgumentParser:
     status = subcommands.add_parser("status", help="Show background server status")
     status.set_defaults(handler=_status)
 
-    install_help = subcommands.add_parser(
-        "install-help",
-        help="Print MCP client configuration examples",
-    )
+    install = subcommands.add_parser("install", help="Show Codex MCP install commands")
+    install.add_argument("--host", default=DEFAULT_HOST)
+    install.add_argument("--port", type=int, default=DEFAULT_PORT)
+    install.set_defaults(handler=lambda args: _print_install(host=args.host, port=args.port))
+
+    install_help = subcommands.add_parser("install-help", help=argparse.SUPPRESS)
     install_help.add_argument("--host", default=DEFAULT_HOST)
     install_help.add_argument("--port", type=int, default=DEFAULT_PORT)
-    install_help.set_defaults(
-        handler=lambda args: _print_install_help(host=args.host, port=args.port)
-    )
+    install_help.set_defaults(handler=lambda args: _print_install(host=args.host, port=args.port))
 
     return parser
 
 
 def main(argv: list[str] | None = None) -> None:
+    argv = sys.argv[1:] if argv is None else argv
+    if not argv or argv in (["-h"], ["--help"]):
+        _print_main_help()
+        return
+
+    if argv[0] not in COMMANDS:
+        print(f"Unknown command: {argv[0]}", file=sys.stderr)
+        print("Run `memtask --help` for usage.", file=sys.stderr)
+        raise SystemExit(2)
+
     parser = build_parser()
     args = parser.parse_args(argv)
     args.handler(args)

{memtask-0.0.1 → memtask-0.0.2}/src/memtask/storage.py

@@ -3,6 +3,7 @@ from __future__ import annotations
 import json
 import os
 import sqlite3
+import tempfile
 from pathlib import Path
 
 
@@ -12,7 +13,17 @@ MEMTASK_DB_PATH_ENV = "MEMTASK_DB_PATH"
 
 
 def default_home() -> Path:
-    return Path(os.environ.get(MEMTASK_HOME_ENV, Path.home() / ".memtask")).expanduser()
+    configured = Path(os.environ.get(MEMTASK_HOME_ENV, Path.home() / ".memtask")).expanduser()
+    try:
+        configured.mkdir(parents=True, exist_ok=True)
+        if os.access(configured, os.W_OK):
+            return configured
+    except OSError:
+        pass
+
+    fallback = Path(tempfile.gettempdir()) / f"memtask-{os.getuid()}"
+    fallback.mkdir(parents=True, exist_ok=True)
+    return fallback
 
 
 def resolve_default_db_path() -> Path:

memtask-0.0.2/src/memtask.egg-info/PKG-INFO

@@ -0,0 +1,89 @@
+Metadata-Version: 2.4
+Name: memtask
+Version: 0.0.2
+Summary: A local MCP server for durable agent task state and lightweight memory.
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: mcp
+Provides-Extra: test
+Requires-Dist: pytest>=8; extra == "test"
+
+<p align="center">
+  <img src="https://raw.githubusercontent.com/PlatinumCD/memtask-mcp/master/docs/assets/memtask-logo.png" alt="MemTask logo" width="220">
+</p>
+
+<h1 align="center">MemTask</h1>
+
+MemTask gives MCP agents a local task list and lightweight memory, backed by SQLite.
+
+## Install
+
+```bash
+pip install MemTask
+```
+
+## Start
+
+```bash
+memtask start
+```
+
+MemTask starts a local MCP server at:
+
+```text
+http://127.0.0.1:8000/mcp
+```
+
+## Add It To Codex
+
+```bash
+memtask install
+```
+
+That prints the exact `codex mcp add ...` commands for stdio and HTTP:
+
+```text
+Codex
+
+stdio server
+  codex mcp add memtask -- memtask start --transport stdio
+
+HTTP server
+  memtask start
+  codex mcp add memtask --url http://127.0.0.1:8000/mcp
+```
+
+## Use It
+
+Once connected, your agent gets tools for:
+
+- tasks: add, list, focus, complete, remove, and track dependencies
+- memory: remember, recall, update, and delete scoped context
+
+## Common Commands
+
+```bash
+memtask status
+memtask stop
+memtask start --transport stdio
+```
+
+## What It Is
+
+MemTask is a local MCP server for developer-built agents that need durable task state and persistent context. It gives an agent a small workspace for tracking active work, dependency order, completed tasks, and scoped memories across sessions.
+
+State is stored locally. In this repo, MemTask uses `data/tasks.sqlite`. When installed outside this repo, it uses `~/.memtask/tasks.sqlite` by default. Set `MEMTASK_DB_PATH` to choose a specific SQLite path.
+
+## Development
+
+Run tests:
+
+```bash
+python -m pytest
+```
+
+Compile-check the package:
+
+```bash
+python -m py_compile src/memtask/*.py tests/*.py
+```

{memtask-0.0.1 → memtask-0.0.2}/tests/test_cli.py

@@ -5,15 +5,53 @@ import json
 from memtask import cli
 
 
-def test_install_help_prints_stdio_and_http_config(capsys) -> None:
-    cli.main(["install-help", "--host", "127.0.0.1", "--port", "9000"])
+def test_no_args_prints_clean_help(capsys) -> None:
+    cli.main([])
 
     output = capsys.readouterr().out
 
-    assert "MemTask MCP configuration examples" in output
-    assert '"command": "memtask"' in output
-    assert '"args": [' in output
-    assert "http://127.0.0.1:9000/mcp" in output
+    assert "Usage" in output
+    assert "memtask start" in output
+    assert "argparse" not in output
+
+
+def test_install_prints_codex_commands_when_not_running(monkeypatch, tmp_path, capsys) -> None:
+    monkeypatch.setenv("MEMTASK_HOME", str(tmp_path))
+
+    cli.main(["install", "--host", "127.0.0.1", "--port", "9000"])
+
+    output = capsys.readouterr().out
+
+    assert output == (
+        "Codex\n"
+        "\n"
+        "stdio server\n"
+        "  codex mcp add memtask -- memtask start --transport stdio\n"
+        "\n"
+        "HTTP server\n"
+        "  memtask start\n"
+        "  codex mcp add memtask --url http://127.0.0.1:9000/mcp\n"
+    )
+
+
+def test_install_uses_running_http_url(monkeypatch, tmp_path, capsys) -> None:
+    monkeypatch.setenv("MEMTASK_HOME", str(tmp_path))
+    (tmp_path / "memtask.pid").write_text(
+        json.dumps(
+            {
+                "pid": 12345,
+                "url": "http://127.0.0.1:9100/mcp",
+            }
+        )
+    )
+    monkeypatch.setattr(cli, "_pid_is_running", lambda pid: True)
+
+    cli.main(["install"])
+
+    output = capsys.readouterr().out
+
+    assert "memtask start\n" not in output
+    assert "codex mcp add memtask --url http://127.0.0.1:9100/mcp" in output
 
 
 def test_start_stdio_prints_guidance_to_stderr(monkeypatch, capsys) -> None:
@@ -29,13 +67,13 @@ def test_start_stdio_prints_guidance_to_stderr(monkeypatch, capsys) -> None:
     captured = capsys.readouterr()
 
     assert captured.out == ""
-    assert "MemTask starting over stdio." in captured.err
-    assert '"command": "memtask"' in captured.err
+    assert "MemTask starting over stdio" in captured.err
+    assert "mcpServers" not in captured.err
     assert called["transport"] == "stdio"
     assert called["server_name"] == "TestTask"
 
 
-def test_start_http_spawns_background_process(monkeypatch, tmp_path, capsys) -> None:
+def test_start_defaults_to_background_http(monkeypatch, tmp_path, capsys) -> None:
     monkeypatch.setenv("MEMTASK_HOME", str(tmp_path))
 
     captured_command = {}
@@ -54,12 +92,12 @@ def test_start_http_spawns_background_process(monkeypatch, tmp_path, capsys) ->
     monkeypatch.setattr(cli.subprocess, "Popen", fake_popen)
     monkeypatch.setattr(cli.time, "sleep", lambda _: None)
 
-    cli.main(["start", "--transport", "http", "--host", "127.0.0.1", "--port", "9001"])
+    cli.main(["start", "--host", "127.0.0.1", "--port", "9001"])
 
     output = capsys.readouterr().out
     pid_record = json.loads((tmp_path / "memtask.pid").read_text())
 
-    assert "MemTask HTTP server started." in output
+    assert "OK MemTask started" in output
     assert "http://127.0.0.1:9001/mcp" in output
     assert pid_record["pid"] == 12345
     assert pid_record["transport"] == "streamable-http"
@@ -77,8 +115,9 @@ def test_stop_without_pid_explains_stdio(monkeypatch, tmp_path, capsys) -> None:
 
     output = capsys.readouterr().out
 
-    assert "No MemTask background server is registered." in output
-    assert "stdio mode" in output
+    assert "MemTask background server is not registered." not in output
+    assert "not running" in output
+    assert "stdio" in output
 
 
 def test_status_without_pid_points_to_install_help(monkeypatch, tmp_path, capsys) -> None:
@@ -88,5 +127,5 @@ def test_status_without_pid_points_to_install_help(monkeypatch, tmp_path, capsys
 
     output = capsys.readouterr().out
 
-    assert "not running" in output
-    assert "memtask install-help" in output
+    assert "MemTask is not running" in output
+    assert "memtask start" in output

memtask-0.0.1/PKG-INFO

@@ -1,104 +0,0 @@
-Metadata-Version: 2.4
-Name: memtask
-Version: 0.0.1
-Summary: A local MCP server for durable agent task state and lightweight memory.
-Requires-Python: >=3.10
-Description-Content-Type: text/markdown
-Requires-Dist: mcp
-Provides-Extra: test
-Requires-Dist: pytest>=8; extra == "test"
-
-<p align="center">
-  <img src="docs/assets/memtask-logo.png" alt="MemTask logo" width="220">
-</p>
-
-<h1 align="center">MemTask</h1>
-
-MemTask is a local MCP server for developer-built agents that need durable task state and lightweight memory. It combines task planning, dependency tracking, active work selection, completion history, and scoped memories in a small SQLite-backed service. The goal is to give agents a structured place to manage agency: what to do next, what depends on what, and what context should persist across sessions.
-
-## What It Provides
-
-MemTask exposes two local primitives over MCP:
-
-- Tasks: pending work, stable task references, parent/child dependency edges, active task selection, and completed task state.
-- Memories: scoped pieces of context with confidence scores, optional parent memory relationships, tags, and task-memory references.
-
-The server is intentionally local-first. State lives in SQLite, the tool surface is small, and the manager layer can be tested directly without running an MCP transport.
-
-## Quickstart
-
-Install MemTask:
-
-```bash
-pip install MemTask
-```
-
-Then ask MemTask for the MCP config to add to your agent:
-
-```bash
-memtask install-help
-```
-
-Most MCP clients should launch MemTask over stdio:
-
-```bash
-memtask start --transport stdio
-```
-
-If your client connects to a running HTTP server instead, start it in the background:
-
-```bash
-memtask start --transport http --host 127.0.0.1 --port 8000
-```
-
-For local development from this repo:
-
-```bash
-PYTHONPATH=src python -m memtask start --transport stdio
-```
-
-Useful HTTP commands: `memtask status` and `memtask stop`.
-
-## Storage
-
-Runtime state in this repo is stored in `data/tasks.sqlite`.
-
-When installed outside this repo, MemTask uses `~/.memtask/tasks.sqlite` by default. Set `MEMTASK_DB_PATH` to choose a specific SQLite path.
-
-The server creates the required SQLite tables on startup using `CREATE TABLE IF NOT EXISTS`. There is no migration framework.
-
-## Tools
-
-Task tools:
-
-- `list_tasks`
-- `get_task`
-- `add_task`
-- `add_batch_tasks`
-- `complete_task`
-- `remove_task`
-- `remove_all_tasks`
-- `current_tasks`
-- `set_current_task`
-
-Memory tools:
-
-- `remember`
-- `recall`
-- `get_memory`
-- `update_memory`
-- `delete_memory`
-
-## Development
-
-Run tests:
-
-```bash
-python -m pytest
-```
-
-Compile-check the package:
-
-```bash
-python -m py_compile src/memtask/*.py tests/*.py
-```

memtask-0.0.1/README.md

@@ -1,94 +0,0 @@
-<p align="center">
-  <img src="docs/assets/memtask-logo.png" alt="MemTask logo" width="220">
-</p>
-
-<h1 align="center">MemTask</h1>
-
-MemTask is a local MCP server for developer-built agents that need durable task state and lightweight memory. It combines task planning, dependency tracking, active work selection, completion history, and scoped memories in a small SQLite-backed service. The goal is to give agents a structured place to manage agency: what to do next, what depends on what, and what context should persist across sessions.
-
-## What It Provides
-
-MemTask exposes two local primitives over MCP:
-
-- Tasks: pending work, stable task references, parent/child dependency edges, active task selection, and completed task state.
-- Memories: scoped pieces of context with confidence scores, optional parent memory relationships, tags, and task-memory references.
-
-The server is intentionally local-first. State lives in SQLite, the tool surface is small, and the manager layer can be tested directly without running an MCP transport.
-
-## Quickstart
-
-Install MemTask:
-
-```bash
-pip install MemTask
-```
-
-Then ask MemTask for the MCP config to add to your agent:
-
-```bash
-memtask install-help
-```
-
-Most MCP clients should launch MemTask over stdio:
-
-```bash
-memtask start --transport stdio
-```
-
-If your client connects to a running HTTP server instead, start it in the background:
-
-```bash
-memtask start --transport http --host 127.0.0.1 --port 8000
-```
-
-For local development from this repo:
-
-```bash
-PYTHONPATH=src python -m memtask start --transport stdio
-```
-
-Useful HTTP commands: `memtask status` and `memtask stop`.
-
-## Storage
-
-Runtime state in this repo is stored in `data/tasks.sqlite`.
-
-When installed outside this repo, MemTask uses `~/.memtask/tasks.sqlite` by default. Set `MEMTASK_DB_PATH` to choose a specific SQLite path.
-
-The server creates the required SQLite tables on startup using `CREATE TABLE IF NOT EXISTS`. There is no migration framework.
-
-## Tools
-
-Task tools:
-
-- `list_tasks`
-- `get_task`
-- `add_task`
-- `add_batch_tasks`
-- `complete_task`
-- `remove_task`
-- `remove_all_tasks`
-- `current_tasks`
-- `set_current_task`
-
-Memory tools:
-
-- `remember`
-- `recall`
-- `get_memory`
-- `update_memory`
-- `delete_memory`
-
-## Development
-
-Run tests:
-
-```bash
-python -m pytest
-```
-
-Compile-check the package:
-
-```bash
-python -m py_compile src/memtask/*.py tests/*.py
-```

memtask-0.0.1/src/memtask.egg-info/PKG-INFO

@@ -1,104 +0,0 @@
-Metadata-Version: 2.4
-Name: memtask
-Version: 0.0.1
-Summary: A local MCP server for durable agent task state and lightweight memory.
-Requires-Python: >=3.10
-Description-Content-Type: text/markdown
-Requires-Dist: mcp
-Provides-Extra: test
-Requires-Dist: pytest>=8; extra == "test"
-
-<p align="center">
-  <img src="docs/assets/memtask-logo.png" alt="MemTask logo" width="220">
-</p>
-
-<h1 align="center">MemTask</h1>
-
-MemTask is a local MCP server for developer-built agents that need durable task state and lightweight memory. It combines task planning, dependency tracking, active work selection, completion history, and scoped memories in a small SQLite-backed service. The goal is to give agents a structured place to manage agency: what to do next, what depends on what, and what context should persist across sessions.
-
-## What It Provides
-
-MemTask exposes two local primitives over MCP:
-
-- Tasks: pending work, stable task references, parent/child dependency edges, active task selection, and completed task state.
-- Memories: scoped pieces of context with confidence scores, optional parent memory relationships, tags, and task-memory references.
-
-The server is intentionally local-first. State lives in SQLite, the tool surface is small, and the manager layer can be tested directly without running an MCP transport.
-
-## Quickstart
-
-Install MemTask:
-
-```bash
-pip install MemTask
-```
-
-Then ask MemTask for the MCP config to add to your agent:
-
-```bash
-memtask install-help
-```
-
-Most MCP clients should launch MemTask over stdio:
-
-```bash
-memtask start --transport stdio
-```
-
-If your client connects to a running HTTP server instead, start it in the background:
-
-```bash
-memtask start --transport http --host 127.0.0.1 --port 8000
-```
-
-For local development from this repo:
-
-```bash
-PYTHONPATH=src python -m memtask start --transport stdio
-```
-
-Useful HTTP commands: `memtask status` and `memtask stop`.
-
-## Storage
-
-Runtime state in this repo is stored in `data/tasks.sqlite`.
-
-When installed outside this repo, MemTask uses `~/.memtask/tasks.sqlite` by default. Set `MEMTASK_DB_PATH` to choose a specific SQLite path.
-
-The server creates the required SQLite tables on startup using `CREATE TABLE IF NOT EXISTS`. There is no migration framework.
-
-## Tools
-
-Task tools:
-
-- `list_tasks`
-- `get_task`
-- `add_task`
-- `add_batch_tasks`
-- `complete_task`
-- `remove_task`
-- `remove_all_tasks`
-- `current_tasks`
-- `set_current_task`
-
-Memory tools:
-
-- `remember`
-- `recall`
-- `get_memory`
-- `update_memory`
-- `delete_memory`
-
-## Development
-
-Run tests:
-
-```bash
-python -m pytest
-```
-
-Compile-check the package:
-
-```bash
-python -m py_compile src/memtask/*.py tests/*.py
-```