memtask 0.0.1__py3-none-any.whl

memtask/storage.py

@@ -0,0 +1,150 @@
+from __future__ import annotations
+
+import json
+import os
+import sqlite3
+from pathlib import Path
+
+
+PROJECT_ROOT = Path(__file__).resolve().parents[2]
+MEMTASK_HOME_ENV = "MEMTASK_HOME"
+MEMTASK_DB_PATH_ENV = "MEMTASK_DB_PATH"
+
+
+def default_home() -> Path:
+    return Path(os.environ.get(MEMTASK_HOME_ENV, Path.home() / ".memtask")).expanduser()
+
+
+def resolve_default_db_path() -> Path:
+    if os.environ.get(MEMTASK_DB_PATH_ENV):
+        return Path(os.environ[MEMTASK_DB_PATH_ENV]).expanduser()
+
+    repo_db_path = PROJECT_ROOT / "data" / "tasks.sqlite"
+    if repo_db_path.exists():
+        return repo_db_path
+
+    return default_home() / "tasks.sqlite"
+
+
+DEFAULT_DB_PATH = resolve_default_db_path()
+DB_PATH = DEFAULT_DB_PATH
+
+
+def set_db_path(path: str | Path) -> None:
+    """Set the SQLite path used by subsequent manager calls."""
+    global DB_PATH
+    DB_PATH = Path(path)
+
+
+def get_db_path() -> Path:
+    return DB_PATH
+
+
+def get_connection() -> sqlite3.Connection:
+    DB_PATH.parent.mkdir(parents=True, exist_ok=True)
+    conn = sqlite3.connect(DB_PATH, detect_types=sqlite3.PARSE_DECLTYPES)
+    conn.row_factory = sqlite3.Row
+    conn.execute("PRAGMA foreign_keys = ON")
+    return conn
+
+
+def init_db() -> None:
+    with get_connection() as conn:
+        conn.executescript(
+            """
+            CREATE TABLE IF NOT EXISTS tasks (
+                task_ref TEXT PRIMARY KEY,
+                description TEXT NOT NULL,
+                project TEXT,
+                tags_json TEXT NOT NULL DEFAULT '[]',
+                memory_refs_json TEXT NOT NULL DEFAULT '[]',
+                status TEXT NOT NULL DEFAULT 'pending',
+                is_current INTEGER NOT NULL DEFAULT 0,
+                created_at REAL NOT NULL,
+                updated_at REAL NOT NULL,
+                completed_at REAL
+            );
+
+            CREATE INDEX IF NOT EXISTS idx_tasks_status ON tasks (status);
+            CREATE INDEX IF NOT EXISTS idx_tasks_is_current ON tasks (is_current);
+
+            CREATE TABLE IF NOT EXISTS memories (
+                memory_id TEXT PRIMARY KEY,
+                content TEXT NOT NULL,
+                memory_scope TEXT NOT NULL DEFAULT 'global',
+                kind TEXT NOT NULL DEFAULT 'fact',
+                confidence INTEGER NOT NULL DEFAULT 100,
+                parent_memory_id TEXT,
+                tags_json TEXT NOT NULL DEFAULT '[]',
+                created_at REAL NOT NULL,
+                updated_at REAL NOT NULL,
+                last_accessed_at REAL,
+                FOREIGN KEY (parent_memory_id) REFERENCES memories (memory_id) ON DELETE SET NULL
+            );
+
+            CREATE INDEX IF NOT EXISTS idx_memories_scope ON memories (memory_scope);
+            CREATE INDEX IF NOT EXISTS idx_memories_kind ON memories (kind);
+            CREATE INDEX IF NOT EXISTS idx_memories_confidence ON memories (confidence);
+            CREATE INDEX IF NOT EXISTS idx_memories_parent ON memories (parent_memory_id);
+
+            CREATE TABLE IF NOT EXISTS task_dependencies (
+                task_ref TEXT NOT NULL,
+                depends_on_task_ref TEXT NOT NULL,
+                PRIMARY KEY (task_ref, depends_on_task_ref),
+                FOREIGN KEY (task_ref) REFERENCES tasks (task_ref) ON DELETE CASCADE,
+                FOREIGN KEY (depends_on_task_ref) REFERENCES tasks (task_ref) ON DELETE CASCADE
+            );
+
+            CREATE INDEX IF NOT EXISTS idx_task_dependencies_task_ref ON task_dependencies (task_ref);
+            CREATE INDEX IF NOT EXISTS idx_task_dependencies_depends_on ON task_dependencies (depends_on_task_ref);
+            """
+        )
+
+
+def normalize_non_empty_string(value: str, label: str) -> str:
+    text = str(value).strip()
+    if not text:
+        raise ValueError(f"{label} is required")
+    return text
+
+
+def normalize_confidence(confidence: int) -> int:
+    if isinstance(confidence, bool) or not isinstance(confidence, int):
+        raise ValueError("confidence must be an integer between 0 and 100")
+    if not 0 <= confidence <= 100:
+        raise ValueError("confidence must be between 0 and 100")
+    return confidence
+
+
+def encode_string_list(values: list[str] | None) -> str:
+    if values is None:
+        return "[]"
+    normalized = []
+    seen = set()
+    for value in values:
+        item = str(value).strip()
+        if not item or item in seen:
+            continue
+        seen.add(item)
+        normalized.append(item)
+    return json.dumps(normalized)
+
+
+def decode_string_list(value: str | None) -> list[str]:
+    if not value:
+        return []
+    try:
+        parsed = json.loads(value)
+    except (TypeError, json.JSONDecodeError):
+        return []
+    if isinstance(parsed, list):
+        return [str(item) for item in parsed]
+    return []
+
+
+def encode_tags(tags: list[str] | None) -> str:
+    return encode_string_list(tags)
+
+
+def decode_tags(value: str | None) -> list[str]:
+    return decode_string_list(value)

memtask-0.0.1.dist-info/METADATA

@@ -0,0 +1,104 @@
+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.dist-info/RECORD

@@ -0,0 +1,12 @@
+memtask/__init__.py,sha256=divNnoUi6IWmEF-sDvLArNGhV7TGKo1NAQizsRdrj08,95
+memtask/__main__.py,sha256=wu5N2wk8mvBgyvr2ghmQf4prezAe0_i-p123VVreyYc,62
+memtask/api.py,sha256=an6h6oZndPz7YR_W2X3kDbThQWPuBvPL1HTFz5mxx6U,11389
+memtask/app.py,sha256=rn0dm4GbdbZ2av4sBT3aRV8hXDdKfxkDaTHvGfFNC5Q,1813
+memtask/cli.py,sha256=vIo3LqBL0HxhlY0uNjqLmjvQd4tCCT87dSa5jDNJ0aA,8313
+memtask/manager.py,sha256=92S57jlFUI2hlO4PsrhN-nOyisZlAfmz-Vy5qWob3ak,24316
+memtask/storage.py,sha256=J4x9X0AlB5yLJ9F1szi_aH-5zvhP46dRk6AZoz3MGSw,4928
+memtask-0.0.1.dist-info/METADATA,sha256=jHsV5GZfV543jQXdqniY7tK1N4U71riMOHxGPGrrSa4,2665
+memtask-0.0.1.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+memtask-0.0.1.dist-info/entry_points.txt,sha256=tL-GQyfa41gXgzWQc3vG6chNQ90S6VgfDH2yMzI45o0,45
+memtask-0.0.1.dist-info/top_level.txt,sha256=h6tvWvx4NeUvwA6UG0IXdjQCc_OL6KIM5TwMWl2Poqw,8
+memtask-0.0.1.dist-info/RECORD,,

memtask-0.0.1.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

memtask-0.0.1.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+memtask = memtask.cli:main

memtask-0.0.1.dist-info/top_level.txt

@@ -0,0 +1 @@
+memtask