seren-margin 1.0.0__py3-none-any.whl

seren_margin/__init__.py

@@ -0,0 +1,19 @@
+"""SerenMargin - private notes-to-self for an AI assistant.
+
+See README.md for the full ethos. The short version: the model writes notes;
+the model decides when to bring them up; the human sees them only on
+offer-and-accept. Standalone service, opt-in by deploy (not by config flag).
+"""
+from __future__ import annotations
+
+from importlib.metadata import PackageNotFoundError, version
+
+try:
+    # The real version is baked into the wheel by setuptools-scm at build time
+    # (from the git tag) and read back here via the installed metadata. This
+    # replaces the old hardcoded "0.1.0" that would report the same string
+    # forever regardless of the tag.
+    __version__: str = version("seren-margin")
+except PackageNotFoundError:
+    # Running from a source checkout without an install (or a tagless tree).
+    __version__ = "0.0.0.dev0"

seren_margin/__main__.py

@@ -0,0 +1,36 @@
+"""Entry point for `python -m seren_margin` or the `seren-margin` script.
+
+Accepts --config / -c to match the SerenMemory convention (Memory leads, the
+rest follow), so the installer can pass the config path explicitly and a buddy
+who learned one service knows this one.
+"""
+from __future__ import annotations
+
+import argparse
+
+import uvicorn
+
+from .app import create_app
+from .config import load_config
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(
+        prog="seren_margin",
+        description="SerenMargin - private notes-to-self for an AI assistant.")
+    parser.add_argument(
+        "--config", "-c", default=None,
+        help="Path to seren-margin.yaml (default: $SEREN_MARGIN_CONFIG, then "
+             "~/seren-margin/seren-margin.yaml, falling back to built-in "
+             "defaults).")
+    args = parser.parse_args()
+
+    cfg = load_config(args.config)
+    app = create_app(cfg)
+
+    print(f"[seren-margin] listening on {cfg.host}:{cfg.port}")
+    uvicorn.run(app, host=cfg.host, port=cfg.port, log_level="info")
+
+
+if __name__ == "__main__":
+    main()

seren_margin/_version.py

@@ -0,0 +1,24 @@
+# file generated by vcs-versioning
+# don't change, don't track in version control
+from __future__ import annotations
+
+__all__ = [
+    "__version__",
+    "__version_tuple__",
+    "version",
+    "version_tuple",
+    "__commit_id__",
+    "commit_id",
+]
+
+version: str
+__version__: str
+__version_tuple__: tuple[int | str, ...]
+version_tuple: tuple[int | str, ...]
+commit_id: str | None
+__commit_id__: str | None
+
+__version__ = version = '1.0.0'
+__version_tuple__ = version_tuple = (1, 0, 0)
+
+__commit_id__ = commit_id = None

seren_margin/app.py

@@ -0,0 +1,144 @@
+"""FastAPI app for SerenMargin.
+
+Endpoints:
+    GET    /                  - service info
+    GET    /health            - liveness probe (Halls integration check)
+    GET    /mcp-manifest       - plug-and-play tool manifest for SerenMcpServer
+    POST   /notes             - write a note (model writes; no system writes)
+    GET    /notes             - list all notes, newest first (corkboard view)
+    GET    /notes/stats       - engine-check view; CONTENT-BLIND
+    GET    /notes/{id}        - fetch one
+    DELETE /notes/{id}        - hard delete
+
+Route order matters: /notes/stats is registered BEFORE /notes/{note_id} so
+FastAPI's path matcher doesn't try to treat 'stats' as an id.
+
+No lifecycle: notes have no pin/expiry/done state and live until deleted, so
+there's no startup sweep and no background janitor.
+"""
+from __future__ import annotations
+
+from contextlib import asynccontextmanager
+from typing import Optional
+
+from fastapi import FastAPI, Body, HTTPException, Request
+from fastapi.responses import Response
+
+from importlib.resources import files
+from importlib.metadata import version as pkg_version, PackageNotFoundError
+
+from . import __version__
+from .config import MarginConfig, load_config
+from .models import MarginNote, NoteCreate, NoteStats
+from .store import MarginStore
+
+
+def create_app(config: Optional[MarginConfig] = None) -> FastAPI:
+    cfg = config or load_config()
+    store = MarginStore(cfg.resolved_db_path())
+
+    @asynccontextmanager
+    async def lifespan(app: FastAPI):
+        # Nothing to sweep - notes live until deleted. Just stash handles.
+        app.state.store = store
+        app.state.cfg = cfg
+        yield
+
+    app = FastAPI(
+        title="SerenMargin",
+        description="Private notes-to-self. Standalone, opt-in, opinionated.",
+        version=__version__,
+        lifespan=lifespan,
+    )
+
+    @app.get("/")
+    async def root():
+        return {
+            "name": "SerenMargin",
+            "version": __version__,
+            "ethos": "private by default, transparent in mechanism, opt-in by deploy",
+            "stats_endpoint": "/notes/stats",
+        }
+
+    @app.get("/mcp-manifest", response_class=Response)
+    def get_mcp_manifest(request: Request) -> Response:
+        """
+        Serve SerenMargin's plug-and-play tool manifest for SerenMcpServer.
+
+        Placeholders are filled in at request time:
+          __BASE_URL__  - request's scheme+host. So the manifest tells the
+                          MCP server to send tool calls back to the SAME
+                          SerenMargin instance the caller just fetched from.
+                          Works for localhost AND remote deployments with
+                          zero operator configuration.
+          __VERSION__   - SerenMargin's installed package version, for the
+                          operator's "what shipped" attribution.
+
+        Content-type is application/yaml so curl + the MCP loader both treat
+        it as YAML. The file lives inside the package (mcp-manifest.yaml
+        sibling to the API modules) so the manifest and the routes can't
+        drift on a release.
+        """
+        base_url = f"{request.url.scheme}://{request.url.netloc}"
+
+        try:
+            version_str = pkg_version("seren-margin")
+        except PackageNotFoundError:
+            # Running from a checkout (editable install or `python -m` from
+            # repo root without `pip install -e .`) - fall back to a stub.
+            version_str = "0.0.0+dev"
+
+        content = (files("seren_margin") / "mcp-manifest.yaml").read_text(encoding="utf-8")
+        content = content.replace("__BASE_URL__", base_url)
+        content = content.replace("__VERSION__", version_str)
+
+        return Response(content=content, media_type="application/yaml")
+
+    @app.get("/health")
+    async def health():
+        return {"ok": True, "service": "seren-margin", "version": __version__}
+
+    # ── note CRUD ─────────────────────────────────────────────────────────
+
+    @app.post("/notes")
+    async def write_note(body: NoteCreate = Body(...)):
+        if not body.content.strip():
+            raise HTTPException(400, "content must not be empty")
+        note = MarginNote(
+            content=body.content.strip(),
+            topic=body.topic,
+            kind=body.kind,
+            extra=body.extra or {},
+        )
+        saved = store.add(note)
+        return {"ok": True, "id": saved.id}
+
+    @app.get("/notes")
+    async def list_notes(limit: int = 100):
+        notes = store.list_all(limit=limit)
+        return {"entries": [n.model_dump() for n in notes], "count": len(notes)}
+
+    @app.get("/notes/stats", response_model=NoteStats)
+    async def get_stats():
+        """Engine-check view. CONTENT-BLIND - returns shape, not text.
+
+        For operators who want to validate the service is working without
+        breaking their stated relational choice not to read individual notes.
+        """
+        return store.stats()
+
+    @app.get("/notes/{note_id}")
+    async def get_note(note_id: str):
+        note = store.get(note_id)
+        if not note:
+            raise HTTPException(404, f"no note '{note_id}'")
+        return note.model_dump()
+
+    @app.delete("/notes/{note_id}")
+    async def delete_note(note_id: str):
+        ok = store.delete(note_id)
+        if not ok:
+            raise HTTPException(404, f"no note '{note_id}'")
+        return {"ok": True, "id": note_id, "deleted": True}
+
+    return app

seren_margin/config.py

@@ -0,0 +1,187 @@
+"""Config for SerenMargin.
+
+Follows the SerenMemory convention (Memory leads, the rest follow) so a
+buddy who set up one service already knows how to set up this one:
+
+    * network settings live under a ``server:`` block (host/port)
+    * config resolves: --config  ->  $SEREN_MARGIN_CONFIG  ->
+      ~/seren-margin/seren-margin.yaml  ->  built-in defaults
+    * the file is named seren-margin.yaml
+
+Lego framing (Chad's): the YAML has a ``server:`` section that this service
+reads, and (future) a ``tools:`` section that a plug-and-play MCP layer reads
+when it wires note-writing tools. Same file, namespaced sections; each piece
+of the stack reads its own block and ignores the rest.
+
+Precedence (highest wins):
+    1. Env vars  (deploy-time escape hatch -- systemd Environment= lines, etc.)
+    2. YAML file (operator's standing config)
+    3. Defaults  (sensible per-user, localhost-only)
+
+Lenient parse (Postel-as-kindness applied to config):
+    - Missing file              -> silently fall back to defaults
+    - Malformed YAML            -> log + fall back to defaults (no crash)
+    - Unparseable single value  -> log + that key falls back; others still apply
+
+Note on the host default: unlike SerenMemory (which defaults host to 0.0.0.0
+for trusted-LAN cluster use), SerenMargin defaults to 127.0.0.1. These are
+PRIVATE notes - they must not land on the network just because the rest of
+the constellation does. Follow-the-leader on structure; NOT on the security
+default. Widen it yourself, on purpose, if you mean to.
+"""
+from __future__ import annotations
+
+import os
+from pathlib import Path
+from typing import Any, Optional
+
+from pydantic import BaseModel
+
+try:
+    import yaml  # type: ignore[import-untyped]
+    _HAS_YAML = True
+except ImportError:  # pragma: no cover - pyyaml is a hard dep, but be lenient
+    _HAS_YAML = False
+
+
+# -- service config model ----------------------------------------------------
+
+
+class MarginConfig(BaseModel):
+    """SerenMargin service config. Defaults are the Nano-floor: per-user,
+    localhost-only, sqlite under the user's home directory.
+    """
+
+    # Where sqlite lives. Per-user default keeps this isolated from any
+    # system-wide path. Operator can override via YAML or env.
+    db_path: str = "~/.seren-margin/notes.db"
+
+    # Bind address. Default localhost-only because this service shouldn't be
+    # exposed to a network without auth in front. Operator decides whether
+    # to widen. (Memory defaults 0.0.0.0; Margin does NOT - private notes.)
+    host: str = "127.0.0.1"
+    port: int = 7421
+
+    # Active notes auto-expire after this many days unless pinned. Done
+    # notes also age out after the same window from done_at, so a
+    # "marked done by mistake" can be reversed if caught within the window.
+    notes_days: int = 30
+
+    def resolved_db_path(self) -> Path:
+        return Path(self.db_path).expanduser()
+
+
+# -- config file resolution --------------------------------------------------
+
+
+# Default config home, matching the Seren ~/seren-<name>/seren-<name>.yaml
+# convention that the installer writes to. (Memory uses the same shape.)
+_DEFAULT_CONFIG_PATH = Path.home() / "seren-margin" / "seren-margin.yaml"
+
+
+def _resolve_config_path(explicit_path: Optional[str] = None) -> Optional[Path]:
+    """Return the path of the config YAML to read, or None if no candidate
+    exists. Resolution order matches SerenMemory:
+
+        1. explicit_path (the --config flag)
+        2. $SEREN_MARGIN_CONFIG
+        3. ~/seren-margin/seren-margin.yaml
+        4. None -> defaults
+
+    Doesn't crash if everything is missing - that's the default case.
+    """
+    # 1. explicit --config wins, used even if missing (operator can `touch`
+    #    it later; the lenient loader handles absent).
+    if explicit_path:
+        return Path(explicit_path).expanduser()
+
+    # 2. env override, same "use even if missing" semantics.
+    env = os.getenv("SEREN_MARGIN_CONFIG")
+    if env:
+        return Path(env).expanduser()
+
+    # 3. the conventional location the installer writes to.
+    if _DEFAULT_CONFIG_PATH.exists():
+        return _DEFAULT_CONFIG_PATH
+
+    return None
+
+
+def _load_yaml_lenient(path: Path) -> dict[str, Any]:
+    """Parse YAML; on any failure return {} and log to stderr. Never crash."""
+    if not path.exists():
+        return {}
+    if not _HAS_YAML:
+        print(f"[seren-margin] config: pyyaml not installed; ignoring {path}")
+        return {}
+    try:
+        with open(path, "r", encoding="utf-8") as f:
+            data = yaml.safe_load(f)
+    except Exception as e:
+        print(f"[seren-margin] config: failed to parse {path}: {e} (using defaults)")
+        return {}
+    if data is None:
+        return {}
+    if not isinstance(data, dict):
+        print(f"[seren-margin] config: {path} top-level must be a mapping; got {type(data).__name__} (using defaults)")
+        return {}
+    return data
+
+
+def _apply_server_overrides(cfg: MarginConfig, server: dict[str, Any], *, source: str) -> None:
+    """Apply per-key overrides to cfg. Each key try/except'd individually so
+    one bad value doesn't take the others down.
+    """
+    # Whitelist of known keys to keep YAML from setting arbitrary attributes.
+    # (If you add a field to MarginConfig, add it here too.)
+    known = {"db_path", "host", "port", "notes_days"}
+    for key, raw in server.items():
+        if key not in known:
+            print(f"[seren-margin] config: ignoring unknown server key '{key}' from {source}")
+            continue
+        try:
+            # Use pydantic's validation by round-tripping through model_validate
+            current = cfg.model_dump()
+            current[key] = raw
+            cfg.__dict__.update(MarginConfig.model_validate(current).__dict__)
+        except Exception as e:
+            print(f"[seren-margin] config: ignored bad value for '{key}' from {source}: {e}")
+
+
+def load_config(path: Optional[str] = None) -> MarginConfig:
+    """Build the runtime config. Defaults -> YAML -> env vars (each layer
+    overrides the prior). Never raises on bad input; logs and falls back.
+
+    ``path`` is the --config flag value (highest-priority config location).
+    """
+    cfg = MarginConfig()
+
+    # Layer 2: YAML
+    yaml_path = _resolve_config_path(path)
+    if yaml_path is not None:
+        data = _load_yaml_lenient(yaml_path)
+        server = data.get("server")
+        if isinstance(server, dict):
+            _apply_server_overrides(cfg, server, source=str(yaml_path))
+        elif server is not None:
+            print(f"[seren-margin] config: 'server' in {yaml_path} must be a mapping; ignoring")
+        # NOTE: data.get('tools') is intentionally NOT read here. That section
+        # is reserved for a future plug-and-play MCP tool layer, which has its
+        # own loader. Same file, different reader, by design.
+
+    # Layer 3: env vars (highest precedence)
+    env_map = {
+        "SEREN_MARGIN_DB": "db_path",
+        "SEREN_MARGIN_HOST": "host",
+        "SEREN_MARGIN_PORT": "port",
+        "SEREN_MARGIN_NOTES_DAYS": "notes_days",
+    }
+    env_overrides: dict[str, Any] = {}
+    for env_key, attr in env_map.items():
+        v = os.getenv(env_key)
+        if v is not None:
+            env_overrides[attr] = v
+    if env_overrides:
+        _apply_server_overrides(cfg, env_overrides, source="environment")
+
+    return cfg

seren_margin/mcp-manifest.yaml

@@ -0,0 +1,94 @@
+# ═══════════════════════════════════════════════════════════════════════
+#  mcp-manifest.yaml - SerenMargin's plug-and-play tool manifest.
+# ═══════════════════════════════════════════════════════════════════════
+#
+#  Served at GET /mcp-manifest. The SerenMcpServer's remote-import
+#  loader fetches this at startup when an operator has dropped a
+#  `from: http://<margin-host>/mcp-manifest` stub in its tools/ dir.
+#
+#  PLACEHOLDERS the route handler substitutes at request time:
+#    __BASE_URL__   request's scheme+host (so the manifest tells the
+#                   MCP to call back to the SAME instance it fetched
+#                   from - works for localhost AND remote with zero
+#                   operator config)
+#    __VERSION__    SerenMargin's installed package version
+#
+#  THREE TOOLS - the minimum corkboard from the AI side:
+#    note_to_self       write a private note          (POST /notes)
+#    list_my_notes      read back active notes        (GET  /notes)
+#    mark_note_done     pull a note from the board    (POST /notes/{id}/done)
+#
+#  Deliberately NOT exposed to the AI (operator-only): pin/unpin,
+#  retract (DELETE), stats. Three is the floor of "functional corkboard"
+#  not the ceiling; add later if a real need surfaces.
+# ═══════════════════════════════════════════════════════════════════════
+
+schema_version: 1
+
+metadata:
+  version: "__VERSION__"
+  license: GPL-3.0-only
+  authors:
+    - { name: Chad Roesler, contact: chad@example.com }
+  site: github.com/ChadRoesler/SerenMargin
+
+configuration:
+  base_url: "__BASE_URL__"
+
+tools:
+  # ─── 1. WRITE ─────────────────────────────────────────────────────────
+  - name: note_to_self
+    description: |
+      Write a private note to yourself. Personal corkboard for reminders,
+      questions to ask later, things you noticed but don't want to surface
+      unprompted. You (the note-holder) decide if and when to bring it up.
+
+      NOT for shared memory about the user or the project - use Remember /
+      RememberForLater for that. NOT for things the user should see
+      directly - say those in chat. Sparing use.
+    invoke:
+      kind: web
+      method: POST
+      path: /notes
+      body_template: |
+        {
+          "content": "{content}",
+          "kind": "{kind}",
+          "pinned": {pinned}
+        }
+    parameters:
+      - { name: content, type: string,  required: true,
+          description: "The note body. Keep it short and imperative." }
+      - { name: kind,    type: string,  required: false, default: observation,
+          description: "What kind of note: observation | reminder | question." }
+      - { name: pinned,  type: boolean, required: false, default: false,
+          description: "Pin this note so it's exempt from auto-aging." }
+
+  # ─── 2. READ ──────────────────────────────────────────────────────────
+  - name: list_my_notes
+    description: |
+      Read back the notes you've written to yourself. Returns active notes
+      only (ones you haven't marked done). Useful when you want to check
+      open threads before responding, or when something in the conversation
+      reminds you of a note from before.
+    invoke:
+      kind: web
+      method: GET
+      path: /notes
+    parameters: []
+
+  # ─── 3. CLOSE THE LOOP ────────────────────────────────────────────────
+  - name: mark_note_done
+    description: |
+      Pull a note from the corkboard - mark it as done. Use when a reminder
+      has been acted on, a question has been answered, or an observation no
+      longer needs surfacing. The note stays in history for audit (not
+      deleted), just no longer active. Requires the note's id from
+      list_my_notes.
+    invoke:
+      kind: web
+      method: POST
+      path: /notes/{id}/done
+    parameters:
+      - { name: id, type: string, required: true,
+          description: "The note's id, as returned by list_my_notes." }

seren_margin/models.py

@@ -0,0 +1,78 @@
+"""Pydantic models for SerenMargin.
+
+A MarginNote is the corkboard primitive: a private note-to-self the model
+writes, reads back when it chooses, and deletes when it's done with it.
+
+Deliberately NO lifecycle machinery - no pin, no expiry, no done-state.
+These are private thoughts you jot down; they live until explicitly deleted.
+The model writes them; the model decides when to surface them; the human sees
+them only on offer-and-accept.
+"""
+from __future__ import annotations
+
+import time
+import uuid
+from typing import Any, Optional
+
+from pydantic import BaseModel, Field
+
+
+def _now() -> float:
+    return time.time()
+
+
+def _new_id() -> str:
+    return uuid.uuid4().hex
+
+
+class MarginNote(BaseModel):
+    """A single private note-to-self.
+
+    Fields:
+      - content: the note text (often imperative)
+      - topic / kind: light organization. kind powers the content-blind stats
+        (it's operator-facing taxonomy, not note content)
+      - ts: write time, stamped by the server
+      - id: stable identifier for fetch/delete
+      - extra: free-form escape hatch for writer-supplied metadata
+
+    Lives until deleted. No pin/expiry/done - see module docstring.
+    """
+
+    content: str = Field(..., description="The note text. Often imperative.")
+    topic: Optional[str] = Field(None)
+    kind: Optional[str] = Field(
+        None,
+        description="Free-form category, e.g. 'reminder' / 'observation'. "
+                    "Intentionally unconstrained - over-classifying private "
+                    "notes adds friction. Let the model write whatever shape "
+                    "it wants.",
+    )
+
+    ts: float = Field(default_factory=_now)
+
+    id: str = Field(default_factory=_new_id)
+    extra: dict[str, Any] = Field(default_factory=dict)
+
+
+class NoteCreate(BaseModel):
+    """Input shape for POST /notes - writer-supplied fields only. Server
+    stamps ts and id.
+    """
+    content: str
+    topic: Optional[str] = None
+    kind: Optional[str] = None
+    extra: dict[str, Any] = Field(default_factory=dict)
+
+
+class NoteStats(BaseModel):
+    """The engine-check view. CONTENT-BLIND by design - exposes shape
+    without exposing what's in the notes.
+
+    This is the surface for 'is the engine running' validation that respects
+    the operator's stated relational stance of not reading individual notes.
+    Kind counts are included (kinds are operator-facing taxonomy rather than
+    note content); content text never appears in this response.
+    """
+    total: int
+    kinds: dict[str, int] = Field(default_factory=dict)

seren_margin/store.py

@@ -0,0 +1,111 @@
+"""Sqlite store for MarginNotes. Tiny, file-based, no embeddings needed.
+
+Schema is deliberately simple - notes-to-self aren't semantic-search material,
+they're corkboard items that live until deleted. The only index targets the
+one access pattern: list by recency.
+
+Thread-safety: each method opens its own short-lived connection. Sqlite is
+fine for this workload (low write rate, single writer in practice).
+"""
+from __future__ import annotations
+
+import json
+import sqlite3
+from pathlib import Path
+from typing import Optional
+
+from .models import MarginNote, NoteStats
+
+
+SCHEMA = """
+CREATE TABLE IF NOT EXISTS notes (
+    id          TEXT PRIMARY KEY,
+    content     TEXT NOT NULL,
+    topic       TEXT,
+    kind        TEXT,
+    ts          REAL NOT NULL,
+    extra       TEXT
+);
+CREATE INDEX IF NOT EXISTS idx_notes_ts ON notes(ts DESC);
+"""
+
+
+class MarginStore:
+    """Sqlite-backed note store."""
+
+    def __init__(self, db_path: Path):
+        self._db_path = db_path
+        self._db_path.parent.mkdir(parents=True, exist_ok=True)
+        with self._conn() as conn:
+            conn.executescript(SCHEMA)
+            conn.commit()
+
+    def _conn(self) -> sqlite3.Connection:
+        conn = sqlite3.connect(self._db_path)
+        conn.row_factory = sqlite3.Row
+        return conn
+
+    # ── writes ────────────────────────────────────────────────────────────
+    def add(self, note: MarginNote) -> MarginNote:
+        with self._conn() as conn:
+            conn.execute(
+                """INSERT INTO notes
+                       (id, content, topic, kind, ts, extra)
+                   VALUES (?, ?, ?, ?, ?, ?)""",
+                (
+                    note.id, note.content, note.topic, note.kind, note.ts,
+                    json.dumps(note.extra or {}),
+                ),
+            )
+            conn.commit()
+        return note
+
+    def delete(self, note_id: str) -> bool:
+        """Hard delete - the one lifecycle control that stays. The model
+        retracts a note when it's done with it; nothing else removes notes.
+        """
+        with self._conn() as conn:
+            cur = conn.execute("DELETE FROM notes WHERE id = ?", (note_id,))
+            conn.commit()
+            return cur.rowcount > 0
+
+    # ── reads ─────────────────────────────────────────────────────────────
+    def get(self, note_id: str) -> Optional[MarginNote]:
+        with self._conn() as conn:
+            row = conn.execute("SELECT * FROM notes WHERE id = ?", (note_id,)).fetchone()
+        return _row_to_note(row) if row else None
+
+    def list_all(self, limit: int = 200) -> list[MarginNote]:
+        """All notes, newest first. They live until deleted, so there's no
+        active/done distinction to filter on - this is the corkboard view.
+        """
+        with self._conn() as conn:
+            rows = conn.execute(
+                "SELECT * FROM notes ORDER BY ts DESC LIMIT ?",
+                (limit,),
+            ).fetchall()
+        return [_row_to_note(r) for r in rows]
+
+    # ── stats (content-blind) ─────────────────────────────────────────────
+    def stats(self) -> NoteStats:
+        """Engine-check shape. No content text appears in this response."""
+        with self._conn() as conn:
+            total = conn.execute("SELECT COUNT(*) FROM notes").fetchone()[0]
+            kind_rows = conn.execute(
+                """SELECT COALESCE(kind, '_unkinded') AS k, COUNT(*) AS c
+                   FROM notes GROUP BY k""",
+            ).fetchall()
+            kinds = {r["k"]: r["c"] for r in kind_rows}
+
+        return NoteStats(total=total, kinds=kinds)
+
+
+def _row_to_note(row: sqlite3.Row) -> MarginNote:
+    return MarginNote(
+        id=row["id"],
+        content=row["content"],
+        topic=row["topic"],
+        kind=row["kind"],
+        ts=row["ts"],
+        extra=json.loads(row["extra"] or "{}"),
+    )

seren_margin-1.0.0.dist-info/METADATA

@@ -0,0 +1,16 @@
+Metadata-Version: 2.4
+Name: seren-margin
+Version: 1.0.0
+Summary: Private notes-to-self for an AI assistant. Standalone, opt-in, opinionated.
+Author: Chad Roesler
+License-Expression: GPL-3.0-only
+Keywords: seren,notes,fastapi,llm,private
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: fastapi>=0.110
+Requires-Dist: uvicorn[standard]>=0.27
+Requires-Dist: pydantic>=2.5
+Requires-Dist: pyyaml>=6.0
+Provides-Extra: test
+Requires-Dist: pytest>=8.0; extra == "test"
+Requires-Dist: httpx>=0.26; extra == "test"

seren_margin-1.0.0.dist-info/RECORD

@@ -0,0 +1,13 @@
+seren_margin/__init__.py,sha256=ar5eGdEgBFtI7RMazOy5EqWXFcsLre-uungDDotoCz8,843
+seren_margin/__main__.py,sha256=7UVUuOAbk-1idj0ZjpA-Z9wIHlictLkK3YOp00MQtmM,1085
+seren_margin/_version.py,sha256=JAAyU3al4wmBf3BF-Umm1J_GrCIT-yS_yWEGHqKRVHc,520
+seren_margin/app.py,sha256=-HI6s4nx-y_uHNWG63rMioM1Rh1hSUsF80cdtFs7Dug,5570
+seren_margin/config.py,sha256=ezRJYSnV3RBjKJztJn4ZuH1gl03HlIMKiG8IGuEZUwI,7338
+seren_margin/mcp-manifest.yaml,sha256=_neq4CQUU8QL4XTLI01GXmgELvXagn5wBq88Xprc4qM,4635
+seren_margin/models.py,sha256=EY7HQNzQWFZEfnZIhYSXllC4-3sn6B4Fm4BF2g9dYJc,2551
+seren_margin/store.py,sha256=32tGRQg86YBS4Ly0bZYi3iJRNXrt3m6-rMTEBlzHfEM,4188
+seren_margin-1.0.0.dist-info/METADATA,sha256=OHKxrCBprQIsO_E9Pcb46JUTATjuyU3-XIbarKsVywQ,535
+seren_margin-1.0.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+seren_margin-1.0.0.dist-info/entry_points.txt,sha256=9Vp1Cd9X2_33MagYf77Gko2zr-aQWuYcBulFkTrj0ug,60
+seren_margin-1.0.0.dist-info/top_level.txt,sha256=Iem1vkHri2k4-cIGuLjubzUDdl6Euyxe42RbvnlfvUc,13
+seren_margin-1.0.0.dist-info/RECORD,,

seren_margin-1.0.0.dist-info/WHEEL

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

seren_margin-1.0.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+seren-margin = seren_margin.__main__:main

seren_margin-1.0.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+seren_margin